修改后台权限

This commit is contained in:
yoyuzh
2026-03-24 14:30:59 +08:00
parent 00f902f475
commit b2d9db7be9
9310 changed files with 1246063 additions and 48 deletions

21
node_modules/msw/LICENSE.md generated vendored Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2018present Artem Zakharchenko
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

279
node_modules/msw/README.md generated vendored Normal file
View File

@@ -0,0 +1,279 @@
<br />
<p align="center">
<img src="media/msw-logo.svg" width="100" alt="The Mock Service Worker logo" />
</p>
<h1 align="center">Mock Service Worker</h1>
<p align="center">Industry standard API mocking for JavaScript.</p>
<p align="center">
<a href="https://kettanaito.com/discord" target="_blank">Join our Discord server</a>
</p>
<br />
<br />
## Features
- **Seamless**. A dedicated layer of requests interception at your disposal. Keep your application's code and tests unaware of whether something is mocked or not.
- **Deviation-free**. Request the same production resources and test the actual behavior of your app. Augment an existing API, or design it as you go when there is none.
- **Familiar & Powerful**. Use [Express](https://github.com/expressjs/express)-like routing syntax to intercept requests. Use parameters, wildcards, and regular expressions to match requests, and respond with necessary status codes, headers, cookies, delays, or completely custom resolvers.
---
> "_I found MSW and was thrilled that not only could I still see the mocked responses in my DevTools, but that the mocks didn't have to be written in a Service Worker and could instead live alongside the rest of my app. This made it silly easy to adopt. The fact that I can use it for testing as well makes MSW a huge productivity booster._"
>
> — [Kent C. Dodds](https://twitter.com/kentcdodds)
## Documentation
This README will give you a brief overview of the library, but there's no better place to start with Mock Service Worker than its official documentation.
- [Documentation](https://mswjs.io/docs)
- [**Quick start**](https://mswjs.io/docs/quick-start)
- [FAQ](https://mswjs.io/docs/faq)
## Examples
- See the list of [**Usage examples**](https://github.com/mswjs/examples)
## Courses
We've partnered with Egghead to bring you quality paid materials to learn the best practices of API mocking on the web. Please give them a shot! The royalties earned from them help sustain the project's development. Thank you.
- 🚀 [**Mocking REST and GraphQL APIs with Mock Service Worker**](https://egghead.io/courses/mock-rest-and-graphql-apis-with-mock-service-worker-8d471ece?af=8mci9b)
- 🔌 [Mocking (and testing) WebSocket APIs with Mock Service Worker](https://egghead.io/courses/mocking-websocket-apis-with-mock-service-worker-9933b7f5)
## Browser
- [Learn more about using MSW in a browser](https://mswjs.io/docs/integrations/browser)
- [`setupWorker` API](https://mswjs.io/docs/api/setup-worker)
### How does it work?
In-browser usage is what sets Mock Service Worker apart from other tools. Utilizing the [Service Worker API](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API), which can intercept requests for the purpose of caching, Mock Service Worker responds to intercepted requests with your mock definition on the network level. This way your application knows nothing about the mocking.
**Take a look at this quick presentation on how Mock Service Worker functions in a browser:**
[![What is Mock Service Worker?](https://raw.githubusercontent.com/mswjs/msw/main/media/msw-video-thumbnail.jpg)](https://youtu.be/HcQCqboatZk)
### How is it different?
- This library intercepts requests on the network level, which means _after_ they have been performed and "left" your application. As a result, the entirety of your code runs, giving you more confidence when mocking;
- Imagine your application as a box. Every API mocking library out there opens your box and removes the part that does the request, placing a blackbox in its stead. Mock Service Worker leaves your box intact, 1-1 as it is in production. Instead, MSW lives in a separate box next to yours;
- No more stubbing of `fetch`, `axios`, `react-query`, you-name-it;
- You can reuse the same mock definition for the unit, integration, and E2E testing. Did we mention local development and debugging? Yep. All running against the same network description without the need for adapters or bloated configurations.
### Usage example
```js
// 1. Import the library.
import { http, HttpResponse } from 'msw'
import { setupWorker } from 'msw/browser'
// 2. Describe network behavior with request handlers.
const worker = setupWorker(
http.get('https://github.com/octocat', ({ request, params, cookies }) => {
return HttpResponse.json(
{
message: 'Mocked response',
},
{
status: 202,
statusText: 'Mocked status',
},
)
}),
)
// 3. Start mocking by starting the Service Worker.
await worker.start()
```
Performing a `GET https://github.com/octocat` request in your application will result into a mocked response that you can inspect in your browser's "Network" tab:
![Chrome DevTools Network screenshot with the request mocked](https://github.com/mswjs/msw/blob/main/media/msw-quick-look-network.png?raw=true)
> **Tip:** Did you know that although Service Worker runs in a separate thread, your request handlers execute entirely on the client? This way you can use the same languages, like TypeScript, third-party libraries, and internal logic to create the mocks you need.
## Node.js
- [Learn more about using MSW in Node.js](https://mswjs.io/docs/integrations/node)
- [`setupServer` API](https://mswjs.io/docs/api/setup-server)
### How does it work?
There's no such thing as Service Workers in Node.js. Instead, MSW implements a [low-level interception algorithm](https://github.com/mswjs/interceptors) that can utilize the very same request handlers you have for the browser. This blends the boundary between environments, allowing you to focus on your network behaviors.
### How is it different?
- Does not stub `fetch`, `axios`, etc. As a result, your tests know _nothing_ about mocking;
- You can reuse the same request handlers for local development and debugging, as well as for testing. Truly a single source of truth for your network behavior across all environments and all tools.
### Usage example
Here's an example of using Mock Service Worker while developing your Express server:
```js
import express from 'express'
import { http, HttpResponse } from 'msw'
import { setupServer } from 'msw/node'
const app = express()
const server = setupServer()
app.get(
'/checkout/session',
server.boundary((req, res) => {
// Describe the network for this Express route.
server.use(
http.get(
'https://api.stripe.com/v1/checkout/sessions/:id',
({ params }) => {
return HttpResponse.json({
id: params.id,
mode: 'payment',
status: 'open',
})
},
),
)
// Continue with processing the checkout session.
handleSession(req, res)
}),
)
```
> This example showcases [`server.boundary()`](https://mswjs.io/docs/api/setup-server/boundary) to scope request interception to a particular closure, which is extremely handy!
## Sponsors
Mock Service Worker is trusted by hundreds of thousands of engineers around the globe. It's used by companies like Google, Microsoft, Spotify, Amazon, Netflix, and countless others. Despite that, it remains a hobby project maintained in a spare time and has no opportunity to financially support even a single full-time contributor.
**You can change that!** Consider [sponsoring the effort](https://github.com/sponsors/mswjs) behind one of the most innovative approaches around API mocking. Raise a topic of open source sponsorships with your boss and colleagues. Let's build sustainable open source together!
### Golden sponsors
> Become our _golden sponsor_ and get featured right here, enjoying other perks like issue prioritization and a personal consulting session with us.
>
> **Learn more on our [GitHub Sponsors profile](https://github.com/sponsors/mswjs)**.
<br />
<table>
<tr>
<td>
<a href="https://www.github.com/" target="_blank">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="media/sponsors/github-light.svg" />
<img src="media/sponsors/github.svg" alt="GitHub" height="64" />
</picture>
</a>
</td>
<td>
<a href="https://www.codacy.com/" target="_blank">
<img src="media/sponsors/codacy.svg" alt="Codacy" height="64" />
</a>
</td>
<td>
<a href="https://workleap.com/" target="_blank">
<img src="media/sponsors/workleap.svg" alt="Workleap" height="64" width="174" />
</a>
</td>
<td>
<a href="https://www.chromatic.com/?ref=mswjs" target="_blank">
<img src="media/sponsors/chromatic.svg" alt="Chromatic" height="64" />
</a>
</td>
</tr>
<tr>
<td align="center">
<a href="https://stackblitz.com/" target="_blank">
<img src="media/sponsors/stackblitz.svg" alt="StackBlitz" height="64" />
</a>
</td>
</tr>
</table>
### Silver sponsors
> Become our _silver sponsor_ and get your profile image and link featured right here.
>
> **Learn more on our [GitHub Sponsors profile](https://github.com/sponsors/mswjs)**.
<br />
<table>
<tr>
<td>
<a href="https://www.replay.io/" target="_blank">
<img src="media/sponsors/replay.svg" alt="Replay" height="64" />
</a>
</td>
<td>
<a href="https://codemod.com/" target="_blank">
<img src="media/sponsors/codemod.svg" alt="Codemod" height="64" width="128" />
</a>
</td>
<td>
<a href="https://github.com/ryanmagoon" target="_blank">
<img src="https://github.com/ryanmagoon.png" alt="Ryan Magoon" height="64" />
</a>
</td>
</tr>
</table>
### Bronze sponsors
> Become our _bronze sponsor_ and get your profile image and link featured in this section.
>
> **Learn more on our [GitHub Sponsors profile](https://github.com/sponsors/mswjs)**.
<br />
<table>
<tr>
<td>
<a href="https://materialize.com/" target="_blank">
<img src="media/sponsors/materialize.svg" alt="Materialize" height="64" />
</a>
</td>
<td>
<a href="https://trigger.dev/" target="_blank">
<img src="media/sponsors/trigger-dev.png" alt="Trigger.dev" height="64" />
</a>
</td>
<td>
<a href="https://vital.io/" target="_blank">
<img src="media/sponsors/vital.svg" alt="Vital" width="64" />
</a>
</td>
</tr>
</table>
## Awards & mentions
We've been extremely humbled to receive awards and mentions from the community for all the innovation and reach Mock Service Worker brings to the JavaScript ecosystem.
<table>
<tr valign="middle">
<td width="124">
<img src="https://raw.githubusercontent.com/mswjs/msw/main/media/tech-radar.png" width="124" alt="Technology Radar">
</td>
<td>
<h4>Solution Worth Pursuing</h4>
<p><em><a href="https://www.thoughtworks.com/radar/languages-and-frameworks/mock-service-worker">Technology Radar</a> (20202021)</em></p>
</td>
</tr>
<tr>
<td width="124">
<img src="https://raw.githubusercontent.com/mswjs/msw/main/media/os-awards.png" width="124" alt="Open Source Awards 2020">
</td>
<td>
<h4>The Most Exciting Use of Technology</h4>
<p><em><a href="https://osawards.com/javascript/2020">Open Source Awards</a> (2020)</em></p>
</td>
</tr>
</table>

31
node_modules/msw/browser/package.json generated vendored Normal file
View File

@@ -0,0 +1,31 @@
{
"type": "module",
"main": "../lib/browser/index.js",
"module": "../lib/browser/index.mjs",
"types": "../lib/browser/index.d.ts",
"exports": {
".": {
"module-sync": {
"types": "./../lib/browser/index.d.mts",
"default": "./../lib/browser/index.mjs"
},
"module": {
"types": "./../lib/browser/index.d.mts",
"default": "./../lib/browser/index.mjs"
},
"browser": {
"types": "./../lib/browser/index.d.mts",
"default": "./../lib/browser/index.mjs"
},
"import": {
"types": "./../lib/browser/index.d.mts",
"default": "./../lib/browser/index.mjs"
},
"default": {
"types": "./../lib/browser/index.d.ts",
"default": "./../lib/browser/index.js"
}
},
"./package.json": "./package.json"
}
}

35
node_modules/msw/cli/index.js generated vendored Executable file
View File

@@ -0,0 +1,35 @@
#!/usr/bin/env node
import yargs from 'yargs'
import { init } from './init.js'
// eslint-disable-next-line @typescript-eslint/no-unused-expressions
yargs(process.argv.slice(2))
.usage('$0 <cmd> [args]')
.command(
'init',
'Initializes Mock Service Worker at the specified directory',
(yargs) => {
yargs
.positional('publicDir', {
type: 'string',
description: 'Relative path to the public directory',
demandOption: false,
normalize: true,
})
.option('save', {
type: 'boolean',
description: 'Save the worker directory in your package.json',
})
.option('cwd', {
type: 'string',
description: 'Custom current worker directory',
normalize: true,
})
.example('msw init')
.example('msw init ./public')
.example('msw init ./static --save')
},
init,
)
.demandCommand()
.help().argv

226
node_modules/msw/cli/init.js generated vendored Normal file
View File

@@ -0,0 +1,226 @@
import fs from 'node:fs'
import path from 'node:path'
import colors from 'picocolors'
import confirm from '@inquirer/confirm'
import { invariant } from './invariant.js'
import { SERVICE_WORKER_BUILD_PATH } from '../config/constants.js'
export async function init(args) {
const CWD = args.cwd || process.cwd()
const publicDir = args._[1] ? normalizePath(args._[1]) : undefined
const packageJsonPath = path.resolve(CWD, 'package.json')
const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
const savedWorkerDirectories = Array.prototype
.concat((packageJson.msw && packageJson.msw.workerDirectory) || [])
.map(normalizePath)
if (publicDir) {
// If the public directory was provided, copy the worker script
// to that directory only. Even if there are paths stored in "msw.workerDirectory",
// those will not be touched.
await copyWorkerScript(publicDir, CWD)
const relativePublicDir = path.relative(CWD, publicDir)
printSuccessMessage([publicDir])
if (args.save) {
// Only save the public path if it's not already saved in "package.json".
if (!savedWorkerDirectories.includes(relativePublicDir)) {
saveWorkerDirectory(packageJsonPath, relativePublicDir)
}
}
// Explicitly check if "save" was not provided (was null).
// You can also provide the "--no-save" option, and then "args.save"
// will equal to false.
else if (args.save == null) {
// eslint-disable-next-line no-console
console.log(`\
${colors.cyan(
'INFO',
)} In order to ease the future updates to the worker script,
we recommend saving the path to the worker directory in your package.json.`)
// If the "--save" flag was not provided, prompt to save
// the public path.
promptWorkerDirectoryUpdate(
`Do you wish to save "${relativePublicDir}" as the worker directory?`,
packageJsonPath,
relativePublicDir,
)
}
return
}
// Calling "init" without a public directory but with the "--save" flag is a no-op.
invariant(
args.save == null,
'Failed to copy the worker script: cannot call the "init" command without a public directory but with the "--save" flag. Either drop the "--save" flag to copy the worker script to all paths listed in "msw.workerDirectory", or add an explicit public directory to the command, like "npx msw init ./public".',
)
// If the public directory was not provided, check any existing
// paths in "msw.workerDirectory". When called without the public
// directory, the "init" command must copy the worker script
// to all the paths stored in "msw.workerDirectory".
if (savedWorkerDirectories.length > 0) {
const copyResults = await Promise.allSettled(
savedWorkerDirectories.map((destination) => {
return copyWorkerScript(destination, CWD).catch((error) => {
// Inject the absolute destination path onto the copy function rejections
// so it's available in the failed paths array below.
throw [toAbsolutePath(destination, CWD), error]
})
}),
)
const successfulPaths = copyResults
.filter((result) => result.status === 'fulfilled')
.map((result) => result.value)
const failedPathsWithErrors = copyResults
.filter((result) => result.status === 'rejected')
.map((result) => result.reason)
// Notify about failed copies, if any.
if (failedPathsWithErrors.length > 0) {
printFailureMessage(failedPathsWithErrors)
}
// Notify about successful copies, if any.
if (successfulPaths.length > 0) {
printSuccessMessage(successfulPaths)
}
}
}
/**
* @param {string} maybeAbsolutePath
* @param {string} cwd
* @returns {string}
*/
function toAbsolutePath(maybeAbsolutePath, cwd) {
return path.isAbsolute(maybeAbsolutePath)
? maybeAbsolutePath
: path.resolve(cwd, maybeAbsolutePath)
}
/**
* @param {string} destination
* @param {string} cwd
* @returns {Promise<string>}
*/
async function copyWorkerScript(destination, cwd) {
// When running as a part of "postinstall" script, "cwd" equals the library's directory.
// The "postinstall" script resolves the right absolute public directory path.
const absolutePublicDir = toAbsolutePath(destination, cwd)
if (!fs.existsSync(absolutePublicDir)) {
await fs.promises
.mkdir(absolutePublicDir, { recursive: true })
.catch((error) => {
throw new Error(
invariant(
false,
'Failed to copy the worker script at "%s": directory does not exist and could not be created.\nMake sure to include a relative path to the public directory of your application.\n\nSee the original error below:\n\n%s',
absolutePublicDir,
error,
),
)
})
}
// eslint-disable-next-line no-console
console.log('Copying the worker script at "%s"...', absolutePublicDir)
const workerFilename = path.basename(SERVICE_WORKER_BUILD_PATH)
const workerDestinationPath = path.resolve(absolutePublicDir, workerFilename)
fs.copyFileSync(SERVICE_WORKER_BUILD_PATH, workerDestinationPath)
return workerDestinationPath
}
/**
* @param {Array<string>} paths
*/
function printSuccessMessage(paths) {
// eslint-disable-next-line no-console
console.log(`
${colors.green('Worker script successfully copied!')}
${paths.map((path) => colors.gray(` - ${path}\n`))}
Continue by describing the network in your application:
${colors.red(colors.bold('https://mswjs.io/docs/quick-start'))}
`)
}
function printFailureMessage(pathsWithErrors) {
// eslint-disable-next-line no-console
console.error(`\
${colors.red('Copying the worker script failed at following paths:')}
${pathsWithErrors
.map(([path, error]) => colors.gray(` - ${path}`) + '\n' + ` ${error}`)
.join('\n\n')}
`)
}
/**
* @param {string} packageJsonPath
* @param {string} publicDir
*/
function saveWorkerDirectory(packageJsonPath, publicDir) {
const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
// eslint-disable-next-line no-console
console.log(
colors.gray('Updating "msw.workerDirectory" at "%s"...'),
packageJsonPath,
)
const prevWorkerDirectory = Array.prototype.concat(
(packageJson.msw && packageJson.msw.workerDirectory) || [],
)
const nextWorkerDirectory = Array.from(
new Set(prevWorkerDirectory).add(publicDir),
)
const nextPackageJson = Object.assign({}, packageJson, {
msw: {
workerDirectory: nextWorkerDirectory,
},
})
fs.writeFileSync(
packageJsonPath,
JSON.stringify(nextPackageJson, null, 2),
'utf8',
)
}
/**
* @param {string} message
* @param {string} packageJsonPath
* @param {string} publicDir
* @returns {void}
*/
function promptWorkerDirectoryUpdate(message, packageJsonPath, publicDir) {
return confirm({
theme: {
prefix: colors.yellowBright('?'),
},
message,
}).then((answer) => {
if (answer) {
saveWorkerDirectory(packageJsonPath, publicDir)
}
})
}
/**
* Normalizes the given path, replacing ambiguous path separators
* with the platform-specific path separator.
* @param {string} input Path to normalize.
* @returns {string}
*/
function normalizePath(input) {
return input.replace(/[\\|\/]+/g, path.sep)
}

9
node_modules/msw/cli/invariant.js generated vendored Normal file
View File

@@ -0,0 +1,9 @@
import colors from 'picocolors'
export function invariant(predicate, message, ...args) {
if (!predicate) {
// eslint-disable-next-line no-console
console.error(colors.red(message), ...args)
process.exit(1)
}
}

3
node_modules/msw/cli/package.json generated vendored Normal file
View File

@@ -0,0 +1,3 @@
{
"type": "module"
}

13
node_modules/msw/config/constants.js generated vendored Normal file
View File

@@ -0,0 +1,13 @@
import url from 'node:url'
import path from 'node:path'
export const SERVICE_WORKER_SOURCE_PATH = url.fileURLToPath(
new URL('../src/mockServiceWorker.js', import.meta.url),
)
export const SERVICE_WORKER_BUILD_PATH = url.fileURLToPath(
new URL(
path.join('../lib', path.basename(SERVICE_WORKER_SOURCE_PATH)),
import.meta.url,
),
)

3
node_modules/msw/config/package.json generated vendored Normal file
View File

@@ -0,0 +1,3 @@
{
"type": "module"
}

36
node_modules/msw/config/scripts/postinstall.js generated vendored Normal file
View File

@@ -0,0 +1,36 @@
import fs from 'node:fs'
import path from 'node:path'
import { execFileSync } from 'node:child_process'
// When executing the "postinstall" script, the "process.cwd" equals
// the package directory, not the parent project where the package is installed.
// NPM stores the parent project directory in the "INIT_CWD" env variable.
const parentPackageCwd = process.env.INIT_CWD
function postInstall() {
const packageJson = JSON.parse(
fs.readFileSync(path.resolve(parentPackageCwd, 'package.json'), 'utf8'),
)
if (!packageJson.msw || !packageJson.msw.workerDirectory) {
return
}
const cliExecutable = path.resolve(process.cwd(), 'cli/index.js')
try {
/**
* @note Call the "init" command directly. It will now copy the worker script
* to all saved paths in "msw.workerDirectory"
*/
execFileSync(process.execPath, [cliExecutable, 'init'], {
cwd: parentPackageCwd,
})
} catch (error) {
console.error(
`[MSW] Failed to automatically update the worker script.\n\n${error}`,
)
}
}
postInstall()

102
node_modules/msw/lib/browser/index.d.mts generated vendored Normal file
View File

@@ -0,0 +1,102 @@
import { SharedOptions, LifeCycleEventEmitter, LifeCycleEventsMap } from "../core/sharedOptions.mjs";
import { RequestHandler } from "../core/handlers/RequestHandler.mjs";
import { WebSocketHandler } from "../core/handlers/WebSocketHandler.mjs";
import { SetupApi } from "../core/SetupApi.mjs";
type FindWorker = (scriptUrl: string, mockServiceWorkerUrl: string) => boolean;
interface StartOptions extends SharedOptions {
/**
* Service Worker registration options.
*/
serviceWorker?: {
/**
* Custom url to the worker script.
* @default "/mockServiceWorker.js"
*/
url?: string;
options?: RegistrationOptions;
};
/**
* Disables the logging of the intercepted requests
* into browser's console.
* @default false
*/
quiet?: boolean;
/**
* Defers any network requests until the Service Worker
* instance is activated.
* @default true
*/
waitUntilReady?: boolean;
/**
* A custom lookup function to find a Mock Service Worker in the list
* of all registered Service Workers on the page.
*/
findWorker?: FindWorker;
}
type StartReturnType = Promise<ServiceWorkerRegistration | undefined>;
type StopHandler = () => void;
interface SetupWorker {
/**
* Registers and activates the mock Service Worker.
*
* @see {@link https://mswjs.io/docs/api/setup-worker/start `worker.start()` API reference}
*/
start: (options?: StartOptions) => StartReturnType;
/**
* Stops requests interception for the current client.
*
* @see {@link https://mswjs.io/docs/api/setup-worker/stop `worker.stop()` API reference}
*/
stop: StopHandler;
/**
* Prepends given request handlers to the list of existing handlers.
* @param {RequestHandler[]} handlers List of runtime request handlers.
*
* @see {@link https://mswjs.io/docs/api/setup-worker/use `worker.use()` API reference}
*/
use: (...handlers: Array<RequestHandler | WebSocketHandler>) => void;
/**
* Marks all request handlers that respond using `res.once()` as unused.
*
* @see {@link https://mswjs.io/docs/api/setup-worker/restore-handlers `worker.restoreHandlers()` API reference}
*/
restoreHandlers: () => void;
/**
* Resets request handlers to the initial list given to the `setupWorker` call, or to the explicit next request handlers list, if given.
* @param {RequestHandler[]} nextHandlers List of the new initial request handlers.
*
* @see {@link https://mswjs.io/docs/api/setup-worker/reset-handlers `worker.resetHandlers()` API reference}
*/
resetHandlers: (...nextHandlers: Array<RequestHandler | WebSocketHandler>) => void;
/**
* Returns a readonly list of currently active request handlers.
*
* @see {@link https://mswjs.io/docs/api/setup-worker/list-handlers `worker.listHandlers()` API reference}
*/
listHandlers(): ReadonlyArray<RequestHandler | WebSocketHandler>;
/**
* Life-cycle events.
* Life-cycle events allow you to subscribe to the internal library events occurring during the request/response handling.
*
* @see {@link https://mswjs.io/docs/api/life-cycle-events Life-cycle Events API reference}
*/
events: LifeCycleEventEmitter<LifeCycleEventsMap>;
}
declare class SetupWorkerApi extends SetupApi<LifeCycleEventsMap> implements SetupWorker {
private context;
constructor(...handlers: Array<RequestHandler | WebSocketHandler>);
private createWorkerContext;
start(options?: StartOptions): StartReturnType;
stop(): void;
}
/**
* Sets up a requests interception in the browser with the given request handlers.
* @param {RequestHandler[]} handlers List of request handlers.
*
* @see {@link https://mswjs.io/docs/api/setup-worker `setupWorker()` API reference}
*/
declare function setupWorker(...handlers: Array<RequestHandler | WebSocketHandler>): SetupWorker;
export { type SetupWorker, SetupWorkerApi, type StartOptions, setupWorker };

102
node_modules/msw/lib/browser/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,102 @@
import { SharedOptions, LifeCycleEventEmitter, LifeCycleEventsMap } from "../core/sharedOptions";
import { RequestHandler } from "../core/handlers/RequestHandler";
import { WebSocketHandler } from "../core/handlers/WebSocketHandler";
import { SetupApi } from "../core/SetupApi";
type FindWorker = (scriptUrl: string, mockServiceWorkerUrl: string) => boolean;
interface StartOptions extends SharedOptions {
/**
* Service Worker registration options.
*/
serviceWorker?: {
/**
* Custom url to the worker script.
* @default "/mockServiceWorker.js"
*/
url?: string;
options?: RegistrationOptions;
};
/**
* Disables the logging of the intercepted requests
* into browser's console.
* @default false
*/
quiet?: boolean;
/**
* Defers any network requests until the Service Worker
* instance is activated.
* @default true
*/
waitUntilReady?: boolean;
/**
* A custom lookup function to find a Mock Service Worker in the list
* of all registered Service Workers on the page.
*/
findWorker?: FindWorker;
}
type StartReturnType = Promise<ServiceWorkerRegistration | undefined>;
type StopHandler = () => void;
interface SetupWorker {
/**
* Registers and activates the mock Service Worker.
*
* @see {@link https://mswjs.io/docs/api/setup-worker/start `worker.start()` API reference}
*/
start: (options?: StartOptions) => StartReturnType;
/**
* Stops requests interception for the current client.
*
* @see {@link https://mswjs.io/docs/api/setup-worker/stop `worker.stop()` API reference}
*/
stop: StopHandler;
/**
* Prepends given request handlers to the list of existing handlers.
* @param {RequestHandler[]} handlers List of runtime request handlers.
*
* @see {@link https://mswjs.io/docs/api/setup-worker/use `worker.use()` API reference}
*/
use: (...handlers: Array<RequestHandler | WebSocketHandler>) => void;
/**
* Marks all request handlers that respond using `res.once()` as unused.
*
* @see {@link https://mswjs.io/docs/api/setup-worker/restore-handlers `worker.restoreHandlers()` API reference}
*/
restoreHandlers: () => void;
/**
* Resets request handlers to the initial list given to the `setupWorker` call, or to the explicit next request handlers list, if given.
* @param {RequestHandler[]} nextHandlers List of the new initial request handlers.
*
* @see {@link https://mswjs.io/docs/api/setup-worker/reset-handlers `worker.resetHandlers()` API reference}
*/
resetHandlers: (...nextHandlers: Array<RequestHandler | WebSocketHandler>) => void;
/**
* Returns a readonly list of currently active request handlers.
*
* @see {@link https://mswjs.io/docs/api/setup-worker/list-handlers `worker.listHandlers()` API reference}
*/
listHandlers(): ReadonlyArray<RequestHandler | WebSocketHandler>;
/**
* Life-cycle events.
* Life-cycle events allow you to subscribe to the internal library events occurring during the request/response handling.
*
* @see {@link https://mswjs.io/docs/api/life-cycle-events Life-cycle Events API reference}
*/
events: LifeCycleEventEmitter<LifeCycleEventsMap>;
}
declare class SetupWorkerApi extends SetupApi<LifeCycleEventsMap> implements SetupWorker {
private context;
constructor(...handlers: Array<RequestHandler | WebSocketHandler>);
private createWorkerContext;
start(options?: StartOptions): StartReturnType;
stop(): void;
}
/**
* Sets up a requests interception in the browser with the given request handlers.
* @param {RequestHandler[]} handlers List of request handlers.
*
* @see {@link https://mswjs.io/docs/api/setup-worker `setupWorker()` API reference}
*/
declare function setupWorker(...handlers: Array<RequestHandler | WebSocketHandler>): SetupWorker;
export { type SetupWorker, SetupWorkerApi, type StartOptions, setupWorker };

2911
node_modules/msw/lib/browser/index.js generated vendored Normal file

File diff suppressed because it is too large Load Diff

1
node_modules/msw/lib/browser/index.js.map generated vendored Normal file

File diff suppressed because one or more lines are too long

2888
node_modules/msw/lib/browser/index.mjs generated vendored Normal file

File diff suppressed because it is too large Load Diff

1
node_modules/msw/lib/browser/index.mjs.map generated vendored Normal file

File diff suppressed because one or more lines are too long

338
node_modules/msw/lib/core/HttpResponse-Be4eT3x6.d.mts generated vendored Normal file
View File

@@ -0,0 +1,338 @@
import { FetchResponse } from '@mswjs/interceptors';
import { Iterable, AsyncIterable } from './utils/internal/isIterable.mjs';
import { MaybePromise, NoInfer } from './typeUtils.mjs';
import { OperationTypeNode, DocumentNode, GraphQLError } from 'graphql';
import { Match, Path } from './utils/matching/matchRequestUrl.mjs';
interface HandlersExecutionResult {
handler: RequestHandler;
parsedResult?: any;
response?: Response;
}
interface ResponseResolutionContext {
/**
* A base url to use when resolving relative urls.
* @note This is primarily used by the `@mswjs/http-middleware`
* to resolve relative urls in the context of the running server
*/
baseUrl?: string;
quiet?: boolean;
}
/**
* Executes the list of request handlers against the given request.
* Returns the execution result object containing any matching request
* handler and any mocked response it returned.
*/
declare const executeHandlers: <Handlers extends Array<RequestHandler>>({ request, requestId, handlers, resolutionContext, }: {
request: Request;
requestId: string;
handlers: Handlers;
resolutionContext?: ResponseResolutionContext;
}) => Promise<HandlersExecutionResult | null>;
interface ParsedGraphQLQuery {
operationType: OperationTypeNode;
operationName?: string;
}
type ParsedGraphQLRequest<VariablesType extends GraphQLVariables = GraphQLVariables> = (ParsedGraphQLQuery & {
query: string;
variables?: VariablesType;
}) | undefined;
declare function parseDocumentNode(node: DocumentNode): ParsedGraphQLQuery;
type GraphQLParsedOperationsMap = Record<string, string[]>;
type GraphQLMultipartRequestBody = {
operations: string;
map?: string;
} & {
[fileName: string]: File;
};
/**
* Determines if a given request can be considered a GraphQL request.
* Does not parse the query and does not guarantee its validity.
*/
declare function parseGraphQLRequest(request: Request): Promise<ParsedGraphQLRequest>;
interface DocumentTypeDecoration<Result = {
[key: string]: any;
}, Variables = {
[key: string]: any;
}> {
__apiType?: (variables: Variables) => Result;
__resultType?: Result;
__variablesType?: Variables;
}
type GraphQLOperationType = OperationTypeNode | 'all';
type GraphQLHandlerNameSelector = DocumentNode | RegExp | string;
type GraphQLQuery = Record<string, any> | null;
type GraphQLVariables = Record<string, any>;
interface GraphQLHandlerInfo extends RequestHandlerDefaultInfo {
operationType: GraphQLOperationType;
operationName: GraphQLHandlerNameSelector | GraphQLCustomPredicate;
}
type GraphQLRequestParsedResult = {
match: Match;
cookies: Record<string, string>;
} & (ParsedGraphQLRequest<GraphQLVariables>
/**
* An empty version of the ParsedGraphQLRequest
* which simplifies the return type of the resolver
* when the request is to a non-matching endpoint
*/
| {
operationType?: undefined;
operationName?: undefined;
query?: undefined;
variables?: undefined;
});
type GraphQLResolverExtras<Variables extends GraphQLVariables> = {
query: string;
operationName: string;
variables: Variables;
cookies: Record<string, string>;
};
type GraphQLRequestBody<VariablesType extends GraphQLVariables> = GraphQLJsonRequestBody<VariablesType> | GraphQLMultipartRequestBody | Record<string, any> | undefined;
interface GraphQLJsonRequestBody<Variables extends GraphQLVariables> {
query: string;
variables?: Variables;
}
type GraphQLResponseBody<BodyType extends DefaultBodyType> = {
data?: BodyType | null;
errors?: readonly Partial<GraphQLError>[] | null;
extensions?: Record<string, any>;
} | null | undefined;
type GraphQLCustomPredicate = (args: {
request: Request;
query: string;
operationType: GraphQLOperationType;
operationName: string;
variables: GraphQLVariables;
cookies: Record<string, string>;
}) => GraphQLCustomPredicateResult | Promise<GraphQLCustomPredicateResult>;
type GraphQLCustomPredicateResult = boolean | {
matches: boolean;
};
type GraphQLPredicate<Query = any, Variables = any> = GraphQLHandlerNameSelector | DocumentTypeDecoration<Query, Variables> | GraphQLCustomPredicate;
declare function isDocumentNode(value: DocumentNode | any): value is DocumentNode;
declare class GraphQLHandler extends RequestHandler<GraphQLHandlerInfo, GraphQLRequestParsedResult, GraphQLResolverExtras<any>> {
#private;
private endpoint;
static parsedRequestCache: WeakMap<Request, ParsedGraphQLRequest<GraphQLVariables>>;
constructor(operationType: GraphQLOperationType, predicate: GraphQLPredicate, endpoint: Path, resolver: ResponseResolver<GraphQLResolverExtras<any>, any, any>, options?: RequestHandlerOptions);
/**
* Parses the request body, once per request, cached across all
* GraphQL handlers. This is done to avoid multiple parsing of the
* request body, which each requires a clone of the request.
*/
parseGraphQLRequestOrGetFromCache(request: Request): Promise<ParsedGraphQLRequest<GraphQLVariables>>;
parse(args: {
request: Request;
}): Promise<GraphQLRequestParsedResult>;
predicate(args: {
request: Request;
parsedResult: GraphQLRequestParsedResult;
}): Promise<boolean>;
run(args: {
request: StrictRequest<any>;
requestId: string;
resolutionContext?: ResponseResolutionContext;
}): Promise<RequestHandlerExecutionResult<GraphQLRequestParsedResult> | null>;
private matchOperationName;
protected extendResolverArgs(args: {
request: Request;
parsedResult: GraphQLRequestParsedResult;
}): {
query: string;
operationType: OperationTypeNode;
operationName: string;
variables: GraphQLVariables;
cookies: Record<string, string>;
};
log(args: {
request: Request;
response: Response;
parsedResult: GraphQLRequestParsedResult;
}): Promise<void>;
}
type DefaultRequestMultipartBody = Record<string, string | File | Array<string | File>>;
type DefaultBodyType = Record<string, any> | DefaultRequestMultipartBody | string | number | boolean | null | undefined;
type JsonBodyType = Record<string, any> | string | number | boolean | null | undefined;
interface RequestHandlerDefaultInfo {
header: string;
}
interface RequestHandlerInternalInfo {
callFrame?: string;
}
type ResponseResolverReturnType<ResponseBodyType extends DefaultBodyType = undefined> = ([ResponseBodyType] extends [undefined] ? Response : ResponseBodyType extends GraphQLRequestBody<any> ? HttpResponse<ResponseBodyType> | DefaultUnsafeFetchResponse : HttpResponse<ResponseBodyType>) | undefined | void;
type MaybeAsyncResponseResolverReturnType<ResponseBodyType extends DefaultBodyType> = MaybePromise<ResponseResolverReturnType<ResponseBodyType>>;
type AsyncResponseResolverReturnType<ResponseBodyType extends DefaultBodyType> = MaybePromise<ResponseResolverReturnType<ResponseBodyType> | Iterable<MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>> | AsyncIterable<MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>>>;
type ResponseResolverInfo<ResolverExtraInfo extends Record<string, unknown>, RequestBodyType extends DefaultBodyType = DefaultBodyType> = {
request: StrictRequest<RequestBodyType>;
requestId: string;
} & ResolverExtraInfo;
type ResponseResolver<ResolverExtraInfo extends Record<string, unknown> = Record<string, unknown>, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = undefined> = (info: ResponseResolverInfo<ResolverExtraInfo, RequestBodyType>) => AsyncResponseResolverReturnType<ResponseBodyType>;
interface RequestHandlerArgs<HandlerInfo, HandlerOptions extends RequestHandlerOptions> {
info: HandlerInfo;
resolver: ResponseResolver<any>;
options?: HandlerOptions;
}
interface RequestHandlerOptions {
once?: boolean;
}
interface RequestHandlerExecutionResult<ParsedResult extends object | undefined> {
handler: RequestHandler;
parsedResult?: ParsedResult;
request: Request;
requestId: string;
response?: Response;
}
declare abstract class RequestHandler<HandlerInfo extends RequestHandlerDefaultInfo = RequestHandlerDefaultInfo, ParsedResult extends Record<string, any> | undefined = any, ResolverExtras extends Record<string, unknown> = any, HandlerOptions extends RequestHandlerOptions = RequestHandlerOptions> {
static cache: WeakMap<StrictRequest<DefaultBodyType>, StrictRequest<DefaultBodyType>>;
private readonly __kind;
info: HandlerInfo & RequestHandlerInternalInfo;
/**
* Indicates whether this request handler has been used
* (its resolver has successfully executed).
*/
isUsed: boolean;
protected resolver: ResponseResolver<ResolverExtras, any, any>;
private resolverIterator?;
private resolverIteratorResult?;
private options?;
constructor(args: RequestHandlerArgs<HandlerInfo, HandlerOptions>);
/**
* Determine if the intercepted request should be mocked.
*/
abstract predicate(args: {
request: Request;
parsedResult: ParsedResult;
resolutionContext?: ResponseResolutionContext;
}): boolean | Promise<boolean>;
/**
* Print out the successfully handled request.
*/
abstract log(args: {
request: Request;
response: Response;
parsedResult: ParsedResult;
}): void;
/**
* Parse the intercepted request to extract additional information from it.
* Parsed result is then exposed to other methods of this request handler.
*/
parse(_args: {
request: Request;
resolutionContext?: ResponseResolutionContext;
}): Promise<ParsedResult>;
/**
* Test if this handler matches the given request.
*
* This method is not used internally but is exposed
* as a convenience method for consumers writing custom
* handlers.
*/
test(args: {
request: Request;
resolutionContext?: ResponseResolutionContext;
}): Promise<boolean>;
protected extendResolverArgs(_args: {
request: Request;
parsedResult: ParsedResult;
}): ResolverExtras;
private cloneRequestOrGetFromCache;
/**
* Execute this request handler and produce a mocked response
* using the given resolver function.
*/
run(args: {
request: StrictRequest<any>;
requestId: string;
resolutionContext?: ResponseResolutionContext;
}): Promise<RequestHandlerExecutionResult<ParsedResult> | null>;
private wrapResolver;
private createExecutionResult;
}
interface HttpResponseInit extends ResponseInit {
type?: ResponseType;
}
declare const bodyType: unique symbol;
type DefaultUnsafeFetchResponse = Response & {
[bodyType]?: never;
};
interface StrictRequest<BodyType extends JsonBodyType> extends Request {
json(): Promise<BodyType>;
clone(): StrictRequest<BodyType>;
}
/**
* Opaque `Response` type that supports strict body type.
*
* @deprecated Please use {@link HttpResponse} instead.
*/
type StrictResponse<BodyType extends DefaultBodyType> = HttpResponse<BodyType>;
declare const kDefaultContentType: unique symbol;
/**
* A drop-in replacement for the standard `Response` class
* to allow additional features, like mocking the response `Set-Cookie` header.
*
* @example
* new HttpResponse('Hello world', { status: 201 })
* HttpResponse.json({ name: 'John' })
* HttpResponse.formData(form)
*
* @see {@link https://mswjs.io/docs/api/http-response `HttpResponse` API reference}
*/
declare class HttpResponse<BodyType extends DefaultBodyType> extends FetchResponse {
readonly [bodyType]: BodyType;
constructor(body?: NoInfer<BodyType> | null, init?: HttpResponseInit);
static error(): HttpResponse<any>;
/**
* Create a `Response` with a `Content-Type: "text/plain"` body.
* @example
* HttpResponse.text('hello world')
* HttpResponse.text('Error', { status: 500 })
*/
static text<BodyType extends string>(body?: NoInfer<BodyType> | null, init?: HttpResponseInit): HttpResponse<BodyType>;
/**
* Create a `Response` with a `Content-Type: "application/json"` body.
* @example
* HttpResponse.json({ firstName: 'John' })
* HttpResponse.json({ error: 'Not Authorized' }, { status: 401 })
*/
static json<BodyType extends JsonBodyType>(body?: NoInfer<BodyType> | null | undefined, init?: HttpResponseInit): HttpResponse<BodyType>;
/**
* Create a `Response` with a `Content-Type: "application/xml"` body.
* @example
* HttpResponse.xml(`<user name="John" />`)
* HttpResponse.xml(`<article id="abc-123" />`, { status: 201 })
*/
static xml<BodyType extends string>(body?: BodyType | null, init?: HttpResponseInit): HttpResponse<BodyType>;
/**
* Create a `Response` with a `Content-Type: "text/html"` body.
* @example
* HttpResponse.html(`<p class="author">Jane Doe</p>`)
* HttpResponse.html(`<main id="abc-123">Main text</main>`, { status: 201 })
*/
static html<BodyType extends string>(body?: BodyType | null, init?: HttpResponseInit): HttpResponse<BodyType>;
/**
* Create a `Response` with an `ArrayBuffer` body.
* @example
* const buffer = new ArrayBuffer(3)
* const view = new Uint8Array(buffer)
* view.set([1, 2, 3])
*
* HttpResponse.arrayBuffer(buffer)
*/
static arrayBuffer<BodyType extends ArrayBuffer | SharedArrayBuffer>(body?: BodyType, init?: HttpResponseInit): HttpResponse<BodyType>;
/**
* Create a `Response` with a `FormData` body.
* @example
* const data = new FormData()
* data.set('name', 'Alice')
*
* HttpResponse.formData(data)
*/
static formData(body?: FormData, init?: HttpResponseInit): HttpResponse<FormData>;
}
export { type AsyncResponseResolverReturnType as A, type GraphQLHandlerNameSelector as B, type GraphQLHandlerInfo as C, type DefaultBodyType as D, type GraphQLRequestParsedResult as E, type GraphQLCustomPredicateResult as F, GraphQLHandler as G, HttpResponse as H, isDocumentNode as I, type JsonBodyType as J, type RequestHandlerInternalInfo as K, type RequestHandlerArgs as L, type MaybeAsyncResponseResolverReturnType as M, type RequestHandlerExecutionResult as N, bodyType as O, type ParsedGraphQLRequest as P, type DefaultUnsafeFetchResponse as Q, RequestHandler as R, type StrictRequest as S, kDefaultContentType as T, type ResponseResolver as a, type ResponseResolverReturnType as b, type RequestHandlerOptions as c, type DefaultRequestMultipartBody as d, type ResponseResolverInfo as e, type GraphQLQuery as f, type GraphQLVariables as g, type GraphQLRequestBody as h, type GraphQLResponseBody as i, type GraphQLJsonRequestBody as j, type GraphQLOperationType as k, type GraphQLCustomPredicate as l, type ResponseResolutionContext as m, type HttpResponseInit as n, type StrictResponse as o, type GraphQLPredicate as p, type GraphQLResolverExtras as q, type RequestHandlerDefaultInfo as r, type HandlersExecutionResult as s, executeHandlers as t, type ParsedGraphQLQuery as u, parseDocumentNode as v, type GraphQLParsedOperationsMap as w, type GraphQLMultipartRequestBody as x, parseGraphQLRequest as y, type DocumentTypeDecoration as z };

338
node_modules/msw/lib/core/HttpResponse-Dj6ibgFJ.d.ts generated vendored Normal file
View File

@@ -0,0 +1,338 @@
import { FetchResponse } from '@mswjs/interceptors';
import { Iterable, AsyncIterable } from './utils/internal/isIterable.js';
import { MaybePromise, NoInfer } from './typeUtils.js';
import { OperationTypeNode, DocumentNode, GraphQLError } from 'graphql';
import { Match, Path } from './utils/matching/matchRequestUrl.js';
interface HandlersExecutionResult {
handler: RequestHandler;
parsedResult?: any;
response?: Response;
}
interface ResponseResolutionContext {
/**
* A base url to use when resolving relative urls.
* @note This is primarily used by the `@mswjs/http-middleware`
* to resolve relative urls in the context of the running server
*/
baseUrl?: string;
quiet?: boolean;
}
/**
* Executes the list of request handlers against the given request.
* Returns the execution result object containing any matching request
* handler and any mocked response it returned.
*/
declare const executeHandlers: <Handlers extends Array<RequestHandler>>({ request, requestId, handlers, resolutionContext, }: {
request: Request;
requestId: string;
handlers: Handlers;
resolutionContext?: ResponseResolutionContext;
}) => Promise<HandlersExecutionResult | null>;
interface ParsedGraphQLQuery {
operationType: OperationTypeNode;
operationName?: string;
}
type ParsedGraphQLRequest<VariablesType extends GraphQLVariables = GraphQLVariables> = (ParsedGraphQLQuery & {
query: string;
variables?: VariablesType;
}) | undefined;
declare function parseDocumentNode(node: DocumentNode): ParsedGraphQLQuery;
type GraphQLParsedOperationsMap = Record<string, string[]>;
type GraphQLMultipartRequestBody = {
operations: string;
map?: string;
} & {
[fileName: string]: File;
};
/**
* Determines if a given request can be considered a GraphQL request.
* Does not parse the query and does not guarantee its validity.
*/
declare function parseGraphQLRequest(request: Request): Promise<ParsedGraphQLRequest>;
interface DocumentTypeDecoration<Result = {
[key: string]: any;
}, Variables = {
[key: string]: any;
}> {
__apiType?: (variables: Variables) => Result;
__resultType?: Result;
__variablesType?: Variables;
}
type GraphQLOperationType = OperationTypeNode | 'all';
type GraphQLHandlerNameSelector = DocumentNode | RegExp | string;
type GraphQLQuery = Record<string, any> | null;
type GraphQLVariables = Record<string, any>;
interface GraphQLHandlerInfo extends RequestHandlerDefaultInfo {
operationType: GraphQLOperationType;
operationName: GraphQLHandlerNameSelector | GraphQLCustomPredicate;
}
type GraphQLRequestParsedResult = {
match: Match;
cookies: Record<string, string>;
} & (ParsedGraphQLRequest<GraphQLVariables>
/**
* An empty version of the ParsedGraphQLRequest
* which simplifies the return type of the resolver
* when the request is to a non-matching endpoint
*/
| {
operationType?: undefined;
operationName?: undefined;
query?: undefined;
variables?: undefined;
});
type GraphQLResolverExtras<Variables extends GraphQLVariables> = {
query: string;
operationName: string;
variables: Variables;
cookies: Record<string, string>;
};
type GraphQLRequestBody<VariablesType extends GraphQLVariables> = GraphQLJsonRequestBody<VariablesType> | GraphQLMultipartRequestBody | Record<string, any> | undefined;
interface GraphQLJsonRequestBody<Variables extends GraphQLVariables> {
query: string;
variables?: Variables;
}
type GraphQLResponseBody<BodyType extends DefaultBodyType> = {
data?: BodyType | null;
errors?: readonly Partial<GraphQLError>[] | null;
extensions?: Record<string, any>;
} | null | undefined;
type GraphQLCustomPredicate = (args: {
request: Request;
query: string;
operationType: GraphQLOperationType;
operationName: string;
variables: GraphQLVariables;
cookies: Record<string, string>;
}) => GraphQLCustomPredicateResult | Promise<GraphQLCustomPredicateResult>;
type GraphQLCustomPredicateResult = boolean | {
matches: boolean;
};
type GraphQLPredicate<Query = any, Variables = any> = GraphQLHandlerNameSelector | DocumentTypeDecoration<Query, Variables> | GraphQLCustomPredicate;
declare function isDocumentNode(value: DocumentNode | any): value is DocumentNode;
declare class GraphQLHandler extends RequestHandler<GraphQLHandlerInfo, GraphQLRequestParsedResult, GraphQLResolverExtras<any>> {
#private;
private endpoint;
static parsedRequestCache: WeakMap<Request, ParsedGraphQLRequest<GraphQLVariables>>;
constructor(operationType: GraphQLOperationType, predicate: GraphQLPredicate, endpoint: Path, resolver: ResponseResolver<GraphQLResolverExtras<any>, any, any>, options?: RequestHandlerOptions);
/**
* Parses the request body, once per request, cached across all
* GraphQL handlers. This is done to avoid multiple parsing of the
* request body, which each requires a clone of the request.
*/
parseGraphQLRequestOrGetFromCache(request: Request): Promise<ParsedGraphQLRequest<GraphQLVariables>>;
parse(args: {
request: Request;
}): Promise<GraphQLRequestParsedResult>;
predicate(args: {
request: Request;
parsedResult: GraphQLRequestParsedResult;
}): Promise<boolean>;
run(args: {
request: StrictRequest<any>;
requestId: string;
resolutionContext?: ResponseResolutionContext;
}): Promise<RequestHandlerExecutionResult<GraphQLRequestParsedResult> | null>;
private matchOperationName;
protected extendResolverArgs(args: {
request: Request;
parsedResult: GraphQLRequestParsedResult;
}): {
query: string;
operationType: OperationTypeNode;
operationName: string;
variables: GraphQLVariables;
cookies: Record<string, string>;
};
log(args: {
request: Request;
response: Response;
parsedResult: GraphQLRequestParsedResult;
}): Promise<void>;
}
type DefaultRequestMultipartBody = Record<string, string | File | Array<string | File>>;
type DefaultBodyType = Record<string, any> | DefaultRequestMultipartBody | string | number | boolean | null | undefined;
type JsonBodyType = Record<string, any> | string | number | boolean | null | undefined;
interface RequestHandlerDefaultInfo {
header: string;
}
interface RequestHandlerInternalInfo {
callFrame?: string;
}
type ResponseResolverReturnType<ResponseBodyType extends DefaultBodyType = undefined> = ([ResponseBodyType] extends [undefined] ? Response : ResponseBodyType extends GraphQLRequestBody<any> ? HttpResponse<ResponseBodyType> | DefaultUnsafeFetchResponse : HttpResponse<ResponseBodyType>) | undefined | void;
type MaybeAsyncResponseResolverReturnType<ResponseBodyType extends DefaultBodyType> = MaybePromise<ResponseResolverReturnType<ResponseBodyType>>;
type AsyncResponseResolverReturnType<ResponseBodyType extends DefaultBodyType> = MaybePromise<ResponseResolverReturnType<ResponseBodyType> | Iterable<MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>> | AsyncIterable<MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>>>;
type ResponseResolverInfo<ResolverExtraInfo extends Record<string, unknown>, RequestBodyType extends DefaultBodyType = DefaultBodyType> = {
request: StrictRequest<RequestBodyType>;
requestId: string;
} & ResolverExtraInfo;
type ResponseResolver<ResolverExtraInfo extends Record<string, unknown> = Record<string, unknown>, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = undefined> = (info: ResponseResolverInfo<ResolverExtraInfo, RequestBodyType>) => AsyncResponseResolverReturnType<ResponseBodyType>;
interface RequestHandlerArgs<HandlerInfo, HandlerOptions extends RequestHandlerOptions> {
info: HandlerInfo;
resolver: ResponseResolver<any>;
options?: HandlerOptions;
}
interface RequestHandlerOptions {
once?: boolean;
}
interface RequestHandlerExecutionResult<ParsedResult extends object | undefined> {
handler: RequestHandler;
parsedResult?: ParsedResult;
request: Request;
requestId: string;
response?: Response;
}
declare abstract class RequestHandler<HandlerInfo extends RequestHandlerDefaultInfo = RequestHandlerDefaultInfo, ParsedResult extends Record<string, any> | undefined = any, ResolverExtras extends Record<string, unknown> = any, HandlerOptions extends RequestHandlerOptions = RequestHandlerOptions> {
static cache: WeakMap<StrictRequest<DefaultBodyType>, StrictRequest<DefaultBodyType>>;
private readonly __kind;
info: HandlerInfo & RequestHandlerInternalInfo;
/**
* Indicates whether this request handler has been used
* (its resolver has successfully executed).
*/
isUsed: boolean;
protected resolver: ResponseResolver<ResolverExtras, any, any>;
private resolverIterator?;
private resolverIteratorResult?;
private options?;
constructor(args: RequestHandlerArgs<HandlerInfo, HandlerOptions>);
/**
* Determine if the intercepted request should be mocked.
*/
abstract predicate(args: {
request: Request;
parsedResult: ParsedResult;
resolutionContext?: ResponseResolutionContext;
}): boolean | Promise<boolean>;
/**
* Print out the successfully handled request.
*/
abstract log(args: {
request: Request;
response: Response;
parsedResult: ParsedResult;
}): void;
/**
* Parse the intercepted request to extract additional information from it.
* Parsed result is then exposed to other methods of this request handler.
*/
parse(_args: {
request: Request;
resolutionContext?: ResponseResolutionContext;
}): Promise<ParsedResult>;
/**
* Test if this handler matches the given request.
*
* This method is not used internally but is exposed
* as a convenience method for consumers writing custom
* handlers.
*/
test(args: {
request: Request;
resolutionContext?: ResponseResolutionContext;
}): Promise<boolean>;
protected extendResolverArgs(_args: {
request: Request;
parsedResult: ParsedResult;
}): ResolverExtras;
private cloneRequestOrGetFromCache;
/**
* Execute this request handler and produce a mocked response
* using the given resolver function.
*/
run(args: {
request: StrictRequest<any>;
requestId: string;
resolutionContext?: ResponseResolutionContext;
}): Promise<RequestHandlerExecutionResult<ParsedResult> | null>;
private wrapResolver;
private createExecutionResult;
}
interface HttpResponseInit extends ResponseInit {
type?: ResponseType;
}
declare const bodyType: unique symbol;
type DefaultUnsafeFetchResponse = Response & {
[bodyType]?: never;
};
interface StrictRequest<BodyType extends JsonBodyType> extends Request {
json(): Promise<BodyType>;
clone(): StrictRequest<BodyType>;
}
/**
* Opaque `Response` type that supports strict body type.
*
* @deprecated Please use {@link HttpResponse} instead.
*/
type StrictResponse<BodyType extends DefaultBodyType> = HttpResponse<BodyType>;
declare const kDefaultContentType: unique symbol;
/**
* A drop-in replacement for the standard `Response` class
* to allow additional features, like mocking the response `Set-Cookie` header.
*
* @example
* new HttpResponse('Hello world', { status: 201 })
* HttpResponse.json({ name: 'John' })
* HttpResponse.formData(form)
*
* @see {@link https://mswjs.io/docs/api/http-response `HttpResponse` API reference}
*/
declare class HttpResponse<BodyType extends DefaultBodyType> extends FetchResponse {
readonly [bodyType]: BodyType;
constructor(body?: NoInfer<BodyType> | null, init?: HttpResponseInit);
static error(): HttpResponse<any>;
/**
* Create a `Response` with a `Content-Type: "text/plain"` body.
* @example
* HttpResponse.text('hello world')
* HttpResponse.text('Error', { status: 500 })
*/
static text<BodyType extends string>(body?: NoInfer<BodyType> | null, init?: HttpResponseInit): HttpResponse<BodyType>;
/**
* Create a `Response` with a `Content-Type: "application/json"` body.
* @example
* HttpResponse.json({ firstName: 'John' })
* HttpResponse.json({ error: 'Not Authorized' }, { status: 401 })
*/
static json<BodyType extends JsonBodyType>(body?: NoInfer<BodyType> | null | undefined, init?: HttpResponseInit): HttpResponse<BodyType>;
/**
* Create a `Response` with a `Content-Type: "application/xml"` body.
* @example
* HttpResponse.xml(`<user name="John" />`)
* HttpResponse.xml(`<article id="abc-123" />`, { status: 201 })
*/
static xml<BodyType extends string>(body?: BodyType | null, init?: HttpResponseInit): HttpResponse<BodyType>;
/**
* Create a `Response` with a `Content-Type: "text/html"` body.
* @example
* HttpResponse.html(`<p class="author">Jane Doe</p>`)
* HttpResponse.html(`<main id="abc-123">Main text</main>`, { status: 201 })
*/
static html<BodyType extends string>(body?: BodyType | null, init?: HttpResponseInit): HttpResponse<BodyType>;
/**
* Create a `Response` with an `ArrayBuffer` body.
* @example
* const buffer = new ArrayBuffer(3)
* const view = new Uint8Array(buffer)
* view.set([1, 2, 3])
*
* HttpResponse.arrayBuffer(buffer)
*/
static arrayBuffer<BodyType extends ArrayBuffer | SharedArrayBuffer>(body?: BodyType, init?: HttpResponseInit): HttpResponse<BodyType>;
/**
* Create a `Response` with a `FormData` body.
* @example
* const data = new FormData()
* data.set('name', 'Alice')
*
* HttpResponse.formData(data)
*/
static formData(body?: FormData, init?: HttpResponseInit): HttpResponse<FormData>;
}
export { type AsyncResponseResolverReturnType as A, type GraphQLHandlerNameSelector as B, type GraphQLHandlerInfo as C, type DefaultBodyType as D, type GraphQLRequestParsedResult as E, type GraphQLCustomPredicateResult as F, GraphQLHandler as G, HttpResponse as H, isDocumentNode as I, type JsonBodyType as J, type RequestHandlerInternalInfo as K, type RequestHandlerArgs as L, type MaybeAsyncResponseResolverReturnType as M, type RequestHandlerExecutionResult as N, bodyType as O, type ParsedGraphQLRequest as P, type DefaultUnsafeFetchResponse as Q, RequestHandler as R, type StrictRequest as S, kDefaultContentType as T, type ResponseResolver as a, type ResponseResolverReturnType as b, type RequestHandlerOptions as c, type DefaultRequestMultipartBody as d, type ResponseResolverInfo as e, type GraphQLQuery as f, type GraphQLVariables as g, type GraphQLRequestBody as h, type GraphQLResponseBody as i, type GraphQLJsonRequestBody as j, type GraphQLOperationType as k, type GraphQLCustomPredicate as l, type ResponseResolutionContext as m, type HttpResponseInit as n, type StrictResponse as o, type GraphQLPredicate as p, type GraphQLResolverExtras as q, type RequestHandlerDefaultInfo as r, type HandlersExecutionResult as s, executeHandlers as t, type ParsedGraphQLQuery as u, parseDocumentNode as v, type GraphQLParsedOperationsMap as w, type GraphQLMultipartRequestBody as x, parseGraphQLRequest as y, type DocumentTypeDecoration as z };

6
node_modules/msw/lib/core/HttpResponse.d.mts generated vendored Normal file
View File

@@ -0,0 +1,6 @@
import '@mswjs/interceptors';
export { Q as DefaultUnsafeFetchResponse, H as HttpResponse, n as HttpResponseInit, S as StrictRequest, o as StrictResponse, O as bodyType, T as kDefaultContentType } from './HttpResponse-Be4eT3x6.mjs';
import './typeUtils.mjs';
import './utils/internal/isIterable.mjs';
import 'graphql';
import './utils/matching/matchRequestUrl.mjs';

6
node_modules/msw/lib/core/HttpResponse.d.ts generated vendored Normal file
View File

@@ -0,0 +1,6 @@
import '@mswjs/interceptors';
export { Q as DefaultUnsafeFetchResponse, H as HttpResponse, n as HttpResponseInit, S as StrictRequest, o as StrictResponse, O as bodyType, T as kDefaultContentType } from './HttpResponse-Dj6ibgFJ.js';
import './typeUtils.js';
import './utils/internal/isIterable.js';
import 'graphql';
import './utils/matching/matchRequestUrl.js';

176
node_modules/msw/lib/core/HttpResponse.js generated vendored Normal file
View File

@@ -0,0 +1,176 @@
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var HttpResponse_exports = {};
__export(HttpResponse_exports, {
HttpResponse: () => HttpResponse,
bodyType: () => bodyType,
kDefaultContentType: () => kDefaultContentType
});
module.exports = __toCommonJS(HttpResponse_exports);
var import_interceptors = require("@mswjs/interceptors");
var import_decorators = require("./utils/HttpResponse/decorators");
const bodyType = Symbol("bodyType");
const kDefaultContentType = Symbol.for("kDefaultContentType");
class HttpResponse extends import_interceptors.FetchResponse {
[bodyType] = null;
constructor(body, init) {
const responseInit = (0, import_decorators.normalizeResponseInit)(init);
super(body, responseInit);
(0, import_decorators.decorateResponse)(this, responseInit);
}
static error() {
return super.error();
}
/**
* Create a `Response` with a `Content-Type: "text/plain"` body.
* @example
* HttpResponse.text('hello world')
* HttpResponse.text('Error', { status: 500 })
*/
static text(body, init) {
const responseInit = (0, import_decorators.normalizeResponseInit)(init);
const hasExplicitContentType = responseInit.headers.has("Content-Type");
if (!hasExplicitContentType) {
responseInit.headers.set("Content-Type", "text/plain");
}
if (!responseInit.headers.has("Content-Length")) {
responseInit.headers.set(
"Content-Length",
body ? new Blob([body]).size.toString() : "0"
);
}
const response = new HttpResponse(body, responseInit);
if (!hasExplicitContentType) {
Object.defineProperty(response, kDefaultContentType, {
value: true,
enumerable: false
});
}
return response;
}
/**
* Create a `Response` with a `Content-Type: "application/json"` body.
* @example
* HttpResponse.json({ firstName: 'John' })
* HttpResponse.json({ error: 'Not Authorized' }, { status: 401 })
*/
static json(body, init) {
const responseInit = (0, import_decorators.normalizeResponseInit)(init);
const hasExplicitContentType = responseInit.headers.has("Content-Type");
if (!hasExplicitContentType) {
responseInit.headers.set("Content-Type", "application/json");
}
const responseText = JSON.stringify(body);
if (!responseInit.headers.has("Content-Length")) {
responseInit.headers.set(
"Content-Length",
responseText ? new Blob([responseText]).size.toString() : "0"
);
}
const response = new HttpResponse(responseText, responseInit);
if (!hasExplicitContentType) {
Object.defineProperty(response, kDefaultContentType, {
value: true,
enumerable: false
});
}
return response;
}
/**
* Create a `Response` with a `Content-Type: "application/xml"` body.
* @example
* HttpResponse.xml(`<user name="John" />`)
* HttpResponse.xml(`<article id="abc-123" />`, { status: 201 })
*/
static xml(body, init) {
const responseInit = (0, import_decorators.normalizeResponseInit)(init);
const hasExplicitContentType = responseInit.headers.has("Content-Type");
if (!hasExplicitContentType) {
responseInit.headers.set("Content-Type", "text/xml");
}
const response = new HttpResponse(body, responseInit);
if (!hasExplicitContentType) {
Object.defineProperty(response, kDefaultContentType, {
value: true,
enumerable: false
});
}
return response;
}
/**
* Create a `Response` with a `Content-Type: "text/html"` body.
* @example
* HttpResponse.html(`<p class="author">Jane Doe</p>`)
* HttpResponse.html(`<main id="abc-123">Main text</main>`, { status: 201 })
*/
static html(body, init) {
const responseInit = (0, import_decorators.normalizeResponseInit)(init);
const hasExplicitContentType = responseInit.headers.has("Content-Type");
if (!hasExplicitContentType) {
responseInit.headers.set("Content-Type", "text/html");
}
const response = new HttpResponse(body, responseInit);
if (!hasExplicitContentType) {
Object.defineProperty(response, kDefaultContentType, {
value: true,
enumerable: false
});
}
return response;
}
/**
* Create a `Response` with an `ArrayBuffer` body.
* @example
* const buffer = new ArrayBuffer(3)
* const view = new Uint8Array(buffer)
* view.set([1, 2, 3])
*
* HttpResponse.arrayBuffer(buffer)
*/
static arrayBuffer(body, init) {
const responseInit = (0, import_decorators.normalizeResponseInit)(init);
const hasExplicitContentType = responseInit.headers.has("Content-Type");
if (!hasExplicitContentType) {
responseInit.headers.set("Content-Type", "application/octet-stream");
}
if (body && !responseInit.headers.has("Content-Length")) {
responseInit.headers.set("Content-Length", body.byteLength.toString());
}
const response = new HttpResponse(body, responseInit);
if (!hasExplicitContentType) {
Object.defineProperty(response, kDefaultContentType, {
value: true,
enumerable: false
});
}
return response;
}
/**
* Create a `Response` with a `FormData` body.
* @example
* const data = new FormData()
* data.set('name', 'Alice')
*
* HttpResponse.formData(data)
*/
static formData(body, init) {
return new HttpResponse(body, (0, import_decorators.normalizeResponseInit)(init));
}
}
//# sourceMappingURL=HttpResponse.js.map

1
node_modules/msw/lib/core/HttpResponse.js.map generated vendored Normal file

File diff suppressed because one or more lines are too long

159
node_modules/msw/lib/core/HttpResponse.mjs generated vendored Normal file
View File

@@ -0,0 +1,159 @@
import { FetchResponse } from "@mswjs/interceptors";
import {
decorateResponse,
normalizeResponseInit
} from './utils/HttpResponse/decorators.mjs';
const bodyType = Symbol("bodyType");
const kDefaultContentType = Symbol.for("kDefaultContentType");
class HttpResponse extends FetchResponse {
[bodyType] = null;
constructor(body, init) {
const responseInit = normalizeResponseInit(init);
super(body, responseInit);
decorateResponse(this, responseInit);
}
static error() {
return super.error();
}
/**
* Create a `Response` with a `Content-Type: "text/plain"` body.
* @example
* HttpResponse.text('hello world')
* HttpResponse.text('Error', { status: 500 })
*/
static text(body, init) {
const responseInit = normalizeResponseInit(init);
const hasExplicitContentType = responseInit.headers.has("Content-Type");
if (!hasExplicitContentType) {
responseInit.headers.set("Content-Type", "text/plain");
}
if (!responseInit.headers.has("Content-Length")) {
responseInit.headers.set(
"Content-Length",
body ? new Blob([body]).size.toString() : "0"
);
}
const response = new HttpResponse(body, responseInit);
if (!hasExplicitContentType) {
Object.defineProperty(response, kDefaultContentType, {
value: true,
enumerable: false
});
}
return response;
}
/**
* Create a `Response` with a `Content-Type: "application/json"` body.
* @example
* HttpResponse.json({ firstName: 'John' })
* HttpResponse.json({ error: 'Not Authorized' }, { status: 401 })
*/
static json(body, init) {
const responseInit = normalizeResponseInit(init);
const hasExplicitContentType = responseInit.headers.has("Content-Type");
if (!hasExplicitContentType) {
responseInit.headers.set("Content-Type", "application/json");
}
const responseText = JSON.stringify(body);
if (!responseInit.headers.has("Content-Length")) {
responseInit.headers.set(
"Content-Length",
responseText ? new Blob([responseText]).size.toString() : "0"
);
}
const response = new HttpResponse(responseText, responseInit);
if (!hasExplicitContentType) {
Object.defineProperty(response, kDefaultContentType, {
value: true,
enumerable: false
});
}
return response;
}
/**
* Create a `Response` with a `Content-Type: "application/xml"` body.
* @example
* HttpResponse.xml(`<user name="John" />`)
* HttpResponse.xml(`<article id="abc-123" />`, { status: 201 })
*/
static xml(body, init) {
const responseInit = normalizeResponseInit(init);
const hasExplicitContentType = responseInit.headers.has("Content-Type");
if (!hasExplicitContentType) {
responseInit.headers.set("Content-Type", "text/xml");
}
const response = new HttpResponse(body, responseInit);
if (!hasExplicitContentType) {
Object.defineProperty(response, kDefaultContentType, {
value: true,
enumerable: false
});
}
return response;
}
/**
* Create a `Response` with a `Content-Type: "text/html"` body.
* @example
* HttpResponse.html(`<p class="author">Jane Doe</p>`)
* HttpResponse.html(`<main id="abc-123">Main text</main>`, { status: 201 })
*/
static html(body, init) {
const responseInit = normalizeResponseInit(init);
const hasExplicitContentType = responseInit.headers.has("Content-Type");
if (!hasExplicitContentType) {
responseInit.headers.set("Content-Type", "text/html");
}
const response = new HttpResponse(body, responseInit);
if (!hasExplicitContentType) {
Object.defineProperty(response, kDefaultContentType, {
value: true,
enumerable: false
});
}
return response;
}
/**
* Create a `Response` with an `ArrayBuffer` body.
* @example
* const buffer = new ArrayBuffer(3)
* const view = new Uint8Array(buffer)
* view.set([1, 2, 3])
*
* HttpResponse.arrayBuffer(buffer)
*/
static arrayBuffer(body, init) {
const responseInit = normalizeResponseInit(init);
const hasExplicitContentType = responseInit.headers.has("Content-Type");
if (!hasExplicitContentType) {
responseInit.headers.set("Content-Type", "application/octet-stream");
}
if (body && !responseInit.headers.has("Content-Length")) {
responseInit.headers.set("Content-Length", body.byteLength.toString());
}
const response = new HttpResponse(body, responseInit);
if (!hasExplicitContentType) {
Object.defineProperty(response, kDefaultContentType, {
value: true,
enumerable: false
});
}
return response;
}
/**
* Create a `Response` with a `FormData` body.
* @example
* const data = new FormData()
* data.set('name', 'Alice')
*
* HttpResponse.formData(data)
*/
static formData(body, init) {
return new HttpResponse(body, normalizeResponseInit(init));
}
}
export {
HttpResponse,
bodyType,
kDefaultContentType
};
//# sourceMappingURL=HttpResponse.mjs.map

1
node_modules/msw/lib/core/HttpResponse.mjs.map generated vendored Normal file

File diff suppressed because one or more lines are too long

44
node_modules/msw/lib/core/SetupApi.d.mts generated vendored Normal file
View File

@@ -0,0 +1,44 @@
import { EventMap, Emitter } from 'strict-event-emitter';
import { R as RequestHandler } from './HttpResponse-Be4eT3x6.mjs';
import { LifeCycleEventEmitter } from './sharedOptions.mjs';
import { Disposable } from './utils/internal/Disposable.mjs';
import { WebSocketHandler } from './handlers/WebSocketHandler.mjs';
import '@mswjs/interceptors';
import './utils/internal/isIterable.mjs';
import './typeUtils.mjs';
import 'graphql';
import './utils/matching/matchRequestUrl.mjs';
import './utils/request/onUnhandledRequest.mjs';
import '@mswjs/interceptors/WebSocket';
declare abstract class HandlersController {
abstract prepend(runtimeHandlers: Array<RequestHandler | WebSocketHandler>): void;
abstract reset(nextHandles: Array<RequestHandler | WebSocketHandler>): void;
abstract currentHandlers(): Array<RequestHandler | WebSocketHandler>;
}
declare class InMemoryHandlersController implements HandlersController {
private initialHandlers;
private handlers;
constructor(initialHandlers: Array<RequestHandler | WebSocketHandler>);
prepend(runtimeHandles: Array<RequestHandler | WebSocketHandler>): void;
reset(nextHandlers: Array<RequestHandler | WebSocketHandler>): void;
currentHandlers(): Array<RequestHandler | WebSocketHandler>;
}
/**
* Generic class for the mock API setup.
*/
declare abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
protected handlersController: HandlersController;
protected readonly emitter: Emitter<EventsMap>;
protected readonly publicEmitter: Emitter<EventsMap>;
readonly events: LifeCycleEventEmitter<EventsMap>;
constructor(...initialHandlers: Array<RequestHandler | WebSocketHandler>);
private validateHandlers;
use(...runtimeHandlers: Array<RequestHandler | WebSocketHandler>): void;
restoreHandlers(): void;
resetHandlers(...nextHandlers: Array<RequestHandler | WebSocketHandler>): void;
listHandlers(): ReadonlyArray<RequestHandler | WebSocketHandler>;
private createLifeCycleEvents;
}
export { HandlersController, InMemoryHandlersController, SetupApi };

44
node_modules/msw/lib/core/SetupApi.d.ts generated vendored Normal file
View File

@@ -0,0 +1,44 @@
import { EventMap, Emitter } from 'strict-event-emitter';
import { R as RequestHandler } from './HttpResponse-Dj6ibgFJ.js';
import { LifeCycleEventEmitter } from './sharedOptions.js';
import { Disposable } from './utils/internal/Disposable.js';
import { WebSocketHandler } from './handlers/WebSocketHandler.js';
import '@mswjs/interceptors';
import './utils/internal/isIterable.js';
import './typeUtils.js';
import 'graphql';
import './utils/matching/matchRequestUrl.js';
import './utils/request/onUnhandledRequest.js';
import '@mswjs/interceptors/WebSocket';
declare abstract class HandlersController {
abstract prepend(runtimeHandlers: Array<RequestHandler | WebSocketHandler>): void;
abstract reset(nextHandles: Array<RequestHandler | WebSocketHandler>): void;
abstract currentHandlers(): Array<RequestHandler | WebSocketHandler>;
}
declare class InMemoryHandlersController implements HandlersController {
private initialHandlers;
private handlers;
constructor(initialHandlers: Array<RequestHandler | WebSocketHandler>);
prepend(runtimeHandles: Array<RequestHandler | WebSocketHandler>): void;
reset(nextHandlers: Array<RequestHandler | WebSocketHandler>): void;
currentHandlers(): Array<RequestHandler | WebSocketHandler>;
}
/**
* Generic class for the mock API setup.
*/
declare abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
protected handlersController: HandlersController;
protected readonly emitter: Emitter<EventsMap>;
protected readonly publicEmitter: Emitter<EventsMap>;
readonly events: LifeCycleEventEmitter<EventsMap>;
constructor(...initialHandlers: Array<RequestHandler | WebSocketHandler>);
private validateHandlers;
use(...runtimeHandlers: Array<RequestHandler | WebSocketHandler>): void;
restoreHandlers(): void;
resetHandlers(...nextHandlers: Array<RequestHandler | WebSocketHandler>): void;
listHandlers(): ReadonlyArray<RequestHandler | WebSocketHandler>;
private createLifeCycleEvents;
}
export { HandlersController, InMemoryHandlersController, SetupApi };

112
node_modules/msw/lib/core/SetupApi.js generated vendored Normal file
View File

@@ -0,0 +1,112 @@
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var SetupApi_exports = {};
__export(SetupApi_exports, {
HandlersController: () => HandlersController,
InMemoryHandlersController: () => InMemoryHandlersController,
SetupApi: () => SetupApi
});
module.exports = __toCommonJS(SetupApi_exports);
var import_outvariant = require("outvariant");
var import_strict_event_emitter = require("strict-event-emitter");
var import_devUtils = require("./utils/internal/devUtils");
var import_pipeEvents = require("./utils/internal/pipeEvents");
var import_toReadonlyArray = require("./utils/internal/toReadonlyArray");
var import_Disposable = require("./utils/internal/Disposable");
class HandlersController {
}
class InMemoryHandlersController {
constructor(initialHandlers) {
this.initialHandlers = initialHandlers;
this.handlers = [...initialHandlers];
}
handlers;
prepend(runtimeHandles) {
this.handlers.unshift(...runtimeHandles);
}
reset(nextHandlers) {
this.handlers = nextHandlers.length > 0 ? [...nextHandlers] : [...this.initialHandlers];
}
currentHandlers() {
return this.handlers;
}
}
class SetupApi extends import_Disposable.Disposable {
handlersController;
emitter;
publicEmitter;
events;
constructor(...initialHandlers) {
super();
(0, import_outvariant.invariant)(
this.validateHandlers(initialHandlers),
import_devUtils.devUtils.formatMessage(
`Failed to apply given request handlers: invalid input. Did you forget to spread the request handlers Array?`
)
);
this.handlersController = new InMemoryHandlersController(initialHandlers);
this.emitter = new import_strict_event_emitter.Emitter();
this.publicEmitter = new import_strict_event_emitter.Emitter();
(0, import_pipeEvents.pipeEvents)(this.emitter, this.publicEmitter);
this.events = this.createLifeCycleEvents();
this.subscriptions.push(() => {
this.emitter.removeAllListeners();
this.publicEmitter.removeAllListeners();
});
}
validateHandlers(handlers) {
return handlers.every((handler) => !Array.isArray(handler));
}
use(...runtimeHandlers) {
(0, import_outvariant.invariant)(
this.validateHandlers(runtimeHandlers),
import_devUtils.devUtils.formatMessage(
`Failed to call "use()" with the given request handlers: invalid input. Did you forget to spread the array of request handlers?`
)
);
this.handlersController.prepend(runtimeHandlers);
}
restoreHandlers() {
this.handlersController.currentHandlers().forEach((handler) => {
if ("isUsed" in handler) {
handler.isUsed = false;
}
});
}
resetHandlers(...nextHandlers) {
this.handlersController.reset(nextHandlers);
}
listHandlers() {
return (0, import_toReadonlyArray.toReadonlyArray)(this.handlersController.currentHandlers());
}
createLifeCycleEvents() {
return {
on: (...args) => {
return this.publicEmitter.on(...args);
},
removeListener: (...args) => {
return this.publicEmitter.removeListener(...args);
},
removeAllListeners: (...args) => {
return this.publicEmitter.removeAllListeners(...args);
}
};
}
}
//# sourceMappingURL=SetupApi.js.map

1
node_modules/msw/lib/core/SetupApi.js.map generated vendored Normal file

File diff suppressed because one or more lines are too long

92
node_modules/msw/lib/core/SetupApi.mjs generated vendored Normal file
View File

@@ -0,0 +1,92 @@
import { invariant } from "outvariant";
import { Emitter } from "strict-event-emitter";
import { devUtils } from './utils/internal/devUtils.mjs';
import { pipeEvents } from './utils/internal/pipeEvents.mjs';
import { toReadonlyArray } from './utils/internal/toReadonlyArray.mjs';
import { Disposable } from './utils/internal/Disposable.mjs';
class HandlersController {
}
class InMemoryHandlersController {
constructor(initialHandlers) {
this.initialHandlers = initialHandlers;
this.handlers = [...initialHandlers];
}
handlers;
prepend(runtimeHandles) {
this.handlers.unshift(...runtimeHandles);
}
reset(nextHandlers) {
this.handlers = nextHandlers.length > 0 ? [...nextHandlers] : [...this.initialHandlers];
}
currentHandlers() {
return this.handlers;
}
}
class SetupApi extends Disposable {
handlersController;
emitter;
publicEmitter;
events;
constructor(...initialHandlers) {
super();
invariant(
this.validateHandlers(initialHandlers),
devUtils.formatMessage(
`Failed to apply given request handlers: invalid input. Did you forget to spread the request handlers Array?`
)
);
this.handlersController = new InMemoryHandlersController(initialHandlers);
this.emitter = new Emitter();
this.publicEmitter = new Emitter();
pipeEvents(this.emitter, this.publicEmitter);
this.events = this.createLifeCycleEvents();
this.subscriptions.push(() => {
this.emitter.removeAllListeners();
this.publicEmitter.removeAllListeners();
});
}
validateHandlers(handlers) {
return handlers.every((handler) => !Array.isArray(handler));
}
use(...runtimeHandlers) {
invariant(
this.validateHandlers(runtimeHandlers),
devUtils.formatMessage(
`Failed to call "use()" with the given request handlers: invalid input. Did you forget to spread the array of request handlers?`
)
);
this.handlersController.prepend(runtimeHandlers);
}
restoreHandlers() {
this.handlersController.currentHandlers().forEach((handler) => {
if ("isUsed" in handler) {
handler.isUsed = false;
}
});
}
resetHandlers(...nextHandlers) {
this.handlersController.reset(nextHandlers);
}
listHandlers() {
return toReadonlyArray(this.handlersController.currentHandlers());
}
createLifeCycleEvents() {
return {
on: (...args) => {
return this.publicEmitter.on(...args);
},
removeListener: (...args) => {
return this.publicEmitter.removeListener(...args);
},
removeAllListeners: (...args) => {
return this.publicEmitter.removeAllListeners(...args);
}
};
}
}
export {
HandlersController,
InMemoryHandlersController,
SetupApi
};
//# sourceMappingURL=SetupApi.mjs.map

1
node_modules/msw/lib/core/SetupApi.mjs.map generated vendored Normal file

File diff suppressed because one or more lines are too long

16
node_modules/msw/lib/core/bypass.d.mts generated vendored Normal file
View File

@@ -0,0 +1,16 @@
type BypassRequestInput = string | URL | Request;
/**
* Creates a `Request` instance that will always be ignored by MSW.
*
* @example
* import { bypass } from 'msw'
*
* fetch(bypass('/resource'))
* fetch(bypass(new URL('/resource', 'https://example.com)))
* fetch(bypass(new Request('https://example.com/resource')))
*
* @see {@link https://mswjs.io/docs/api/bypass `bypass()` API reference}
*/
declare function bypass(input: BypassRequestInput, init?: RequestInit): Request;
export { type BypassRequestInput, bypass };

16
node_modules/msw/lib/core/bypass.d.ts generated vendored Normal file
View File

@@ -0,0 +1,16 @@
type BypassRequestInput = string | URL | Request;
/**
* Creates a `Request` instance that will always be ignored by MSW.
*
* @example
* import { bypass } from 'msw'
*
* fetch(bypass('/resource'))
* fetch(bypass(new URL('/resource', 'https://example.com)))
* fetch(bypass(new Request('https://example.com/resource')))
*
* @see {@link https://mswjs.io/docs/api/bypass `bypass()` API reference}
*/
declare function bypass(input: BypassRequestInput, init?: RequestInit): Request;
export { type BypassRequestInput, bypass };

42
node_modules/msw/lib/core/bypass.js generated vendored Normal file
View File

@@ -0,0 +1,42 @@
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var bypass_exports = {};
__export(bypass_exports, {
bypass: () => bypass
});
module.exports = __toCommonJS(bypass_exports);
var import_outvariant = require("outvariant");
function bypass(input, init) {
const request = new Request(
// If given a Request instance, clone it not to exhaust
// the original request's body.
input instanceof Request ? input.clone() : input,
init
);
(0, import_outvariant.invariant)(
!request.bodyUsed,
'Failed to create a bypassed request to "%s %s": given request instance already has its body read. Make sure to clone the intercepted request if you wish to read its body before bypassing it.',
request.method,
request.url
);
const requestClone = request.clone();
requestClone.headers.append("accept", "msw/passthrough");
return requestClone;
}
//# sourceMappingURL=bypass.js.map

1
node_modules/msw/lib/core/bypass.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../src/core/bypass.ts"],"sourcesContent":["import { invariant } from 'outvariant'\n\nexport type BypassRequestInput = string | URL | Request\n\n/**\n * Creates a `Request` instance that will always be ignored by MSW.\n *\n * @example\n * import { bypass } from 'msw'\n *\n * fetch(bypass('/resource'))\n * fetch(bypass(new URL('/resource', 'https://example.com)))\n * fetch(bypass(new Request('https://example.com/resource')))\n *\n * @see {@link https://mswjs.io/docs/api/bypass `bypass()` API reference}\n */\nexport function bypass(input: BypassRequestInput, init?: RequestInit): Request {\n // Always create a new Request instance.\n // This way, the \"init\" modifications will propagate\n // to the bypass request instance automatically.\n const request = new Request(\n // If given a Request instance, clone it not to exhaust\n // the original request's body.\n input instanceof Request ? input.clone() : input,\n init,\n )\n\n invariant(\n !request.bodyUsed,\n 'Failed to create a bypassed request to \"%s %s\": given request instance already has its body read. Make sure to clone the intercepted request if you wish to read its body before bypassing it.',\n request.method,\n request.url,\n )\n\n const requestClone = request.clone()\n\n /**\n * Send the internal request header that would instruct MSW\n * to perform this request as-is, ignoring any matching handlers.\n * @note Use the `accept` header to support scenarios when the\n * request cannot have headers (e.g. `sendBeacon` requests).\n */\n requestClone.headers.append('accept', 'msw/passthrough')\n\n return requestClone\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAA0B;AAgBnB,SAAS,OAAO,OAA2B,MAA6B;AAI7E,QAAM,UAAU,IAAI;AAAA;AAAA;AAAA,IAGlB,iBAAiB,UAAU,MAAM,MAAM,IAAI;AAAA,IAC3C;AAAA,EACF;AAEA;AAAA,IACE,CAAC,QAAQ;AAAA,IACT;AAAA,IACA,QAAQ;AAAA,IACR,QAAQ;AAAA,EACV;AAEA,QAAM,eAAe,QAAQ,MAAM;AAQnC,eAAa,QAAQ,OAAO,UAAU,iBAAiB;AAEvD,SAAO;AACT;","names":[]}

22
node_modules/msw/lib/core/bypass.mjs generated vendored Normal file
View File

@@ -0,0 +1,22 @@
import { invariant } from "outvariant";
function bypass(input, init) {
const request = new Request(
// If given a Request instance, clone it not to exhaust
// the original request's body.
input instanceof Request ? input.clone() : input,
init
);
invariant(
!request.bodyUsed,
'Failed to create a bypassed request to "%s %s": given request instance already has its body read. Make sure to clone the intercepted request if you wish to read its body before bypassing it.',
request.method,
request.url
);
const requestClone = request.clone();
requestClone.headers.append("accept", "msw/passthrough");
return requestClone;
}
export {
bypass
};
//# sourceMappingURL=bypass.mjs.map

1
node_modules/msw/lib/core/bypass.mjs.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../src/core/bypass.ts"],"sourcesContent":["import { invariant } from 'outvariant'\n\nexport type BypassRequestInput = string | URL | Request\n\n/**\n * Creates a `Request` instance that will always be ignored by MSW.\n *\n * @example\n * import { bypass } from 'msw'\n *\n * fetch(bypass('/resource'))\n * fetch(bypass(new URL('/resource', 'https://example.com)))\n * fetch(bypass(new Request('https://example.com/resource')))\n *\n * @see {@link https://mswjs.io/docs/api/bypass `bypass()` API reference}\n */\nexport function bypass(input: BypassRequestInput, init?: RequestInit): Request {\n // Always create a new Request instance.\n // This way, the \"init\" modifications will propagate\n // to the bypass request instance automatically.\n const request = new Request(\n // If given a Request instance, clone it not to exhaust\n // the original request's body.\n input instanceof Request ? input.clone() : input,\n init,\n )\n\n invariant(\n !request.bodyUsed,\n 'Failed to create a bypassed request to \"%s %s\": given request instance already has its body read. Make sure to clone the intercepted request if you wish to read its body before bypassing it.',\n request.method,\n request.url,\n )\n\n const requestClone = request.clone()\n\n /**\n * Send the internal request header that would instruct MSW\n * to perform this request as-is, ignoring any matching handlers.\n * @note Use the `accept` header to support scenarios when the\n * request cannot have headers (e.g. `sendBeacon` requests).\n */\n requestClone.headers.append('accept', 'msw/passthrough')\n\n return requestClone\n}\n"],"mappings":"AAAA,SAAS,iBAAiB;AAgBnB,SAAS,OAAO,OAA2B,MAA6B;AAI7E,QAAM,UAAU,IAAI;AAAA;AAAA;AAAA,IAGlB,iBAAiB,UAAU,MAAM,MAAM,IAAI;AAAA,IAC3C;AAAA,EACF;AAEA;AAAA,IACE,CAAC,QAAQ;AAAA,IACT;AAAA,IACA,QAAQ;AAAA,IACR,QAAQ;AAAA,EACV;AAEA,QAAM,eAAe,QAAQ,MAAM;AAQnC,eAAa,QAAQ,OAAO,UAAU,iBAAiB;AAEvD,SAAO;AACT;","names":[]}

18
node_modules/msw/lib/core/delay.d.mts generated vendored Normal file
View File

@@ -0,0 +1,18 @@
declare const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
declare const MIN_SERVER_RESPONSE_TIME = 100;
declare const MAX_SERVER_RESPONSE_TIME = 400;
declare const NODE_SERVER_RESPONSE_TIME = 5;
type DelayMode = 'real' | 'infinite';
/**
* Delays the response by the given duration (ms).
*
* @example
* await delay() // emulate realistic server response time
* await delay(1200) // delay response by 1200ms
* await delay('infinite') // delay response infinitely
*
* @see {@link https://mswjs.io/docs/api/delay `delay()` API reference}
*/
declare function delay(durationOrMode?: DelayMode | number): Promise<void>;
export { type DelayMode, MAX_SERVER_RESPONSE_TIME, MIN_SERVER_RESPONSE_TIME, NODE_SERVER_RESPONSE_TIME, SET_TIMEOUT_MAX_ALLOWED_INT, delay };

18
node_modules/msw/lib/core/delay.d.ts generated vendored Normal file
View File

@@ -0,0 +1,18 @@
declare const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
declare const MIN_SERVER_RESPONSE_TIME = 100;
declare const MAX_SERVER_RESPONSE_TIME = 400;
declare const NODE_SERVER_RESPONSE_TIME = 5;
type DelayMode = 'real' | 'infinite';
/**
* Delays the response by the given duration (ms).
*
* @example
* await delay() // emulate realistic server response time
* await delay(1200) // delay response by 1200ms
* await delay('infinite') // delay response infinitely
*
* @see {@link https://mswjs.io/docs/api/delay `delay()` API reference}
*/
declare function delay(durationOrMode?: DelayMode | number): Promise<void>;
export { type DelayMode, MAX_SERVER_RESPONSE_TIME, MIN_SERVER_RESPONSE_TIME, NODE_SERVER_RESPONSE_TIME, SET_TIMEOUT_MAX_ALLOWED_INT, delay };

77
node_modules/msw/lib/core/delay.js generated vendored Normal file
View File

@@ -0,0 +1,77 @@
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var delay_exports = {};
__export(delay_exports, {
MAX_SERVER_RESPONSE_TIME: () => MAX_SERVER_RESPONSE_TIME,
MIN_SERVER_RESPONSE_TIME: () => MIN_SERVER_RESPONSE_TIME,
NODE_SERVER_RESPONSE_TIME: () => NODE_SERVER_RESPONSE_TIME,
SET_TIMEOUT_MAX_ALLOWED_INT: () => SET_TIMEOUT_MAX_ALLOWED_INT,
delay: () => delay
});
module.exports = __toCommonJS(delay_exports);
var import_is_node_process = require("is-node-process");
var import_hasRefCounted = require("./utils/internal/hasRefCounted");
const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
const MIN_SERVER_RESPONSE_TIME = 100;
const MAX_SERVER_RESPONSE_TIME = 400;
const NODE_SERVER_RESPONSE_TIME = 5;
function getRealisticResponseTime() {
if ((0, import_is_node_process.isNodeProcess)()) {
return NODE_SERVER_RESPONSE_TIME;
}
return Math.floor(
Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) + MIN_SERVER_RESPONSE_TIME
);
}
async function delay(durationOrMode) {
let delayTime;
if (typeof durationOrMode === "string") {
switch (durationOrMode) {
case "infinite": {
delayTime = SET_TIMEOUT_MAX_ALLOWED_INT;
break;
}
case "real": {
delayTime = getRealisticResponseTime();
break;
}
default: {
throw new Error(
`Failed to delay a response: unknown delay mode "${durationOrMode}". Please make sure you provide one of the supported modes ("real", "infinite") or a number.`
);
}
}
} else if (typeof durationOrMode === "undefined") {
delayTime = getRealisticResponseTime();
} else {
if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {
throw new Error(
`Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for "setTimeout" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the "infinite" delay mode to delay the response indefinitely.`
);
}
delayTime = durationOrMode;
}
return new Promise((resolve) => {
const timeoutId = setTimeout(resolve, delayTime);
if (delayTime === SET_TIMEOUT_MAX_ALLOWED_INT && (0, import_is_node_process.isNodeProcess)() && (0, import_hasRefCounted.hasRefCounted)(timeoutId)) {
timeoutId.unref();
}
});
}
//# sourceMappingURL=delay.js.map

1
node_modules/msw/lib/core/delay.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../src/core/delay.ts"],"sourcesContent":["import { isNodeProcess } from 'is-node-process'\nimport { hasRefCounted } from './utils/internal/hasRefCounted'\n\nexport const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647\nexport const MIN_SERVER_RESPONSE_TIME = 100\nexport const MAX_SERVER_RESPONSE_TIME = 400\nexport const NODE_SERVER_RESPONSE_TIME = 5\n\nfunction getRealisticResponseTime(): number {\n if (isNodeProcess()) {\n return NODE_SERVER_RESPONSE_TIME\n }\n\n return Math.floor(\n Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) +\n MIN_SERVER_RESPONSE_TIME,\n )\n}\n\nexport type DelayMode = 'real' | 'infinite'\n\n/**\n * Delays the response by the given duration (ms).\n *\n * @example\n * await delay() // emulate realistic server response time\n * await delay(1200) // delay response by 1200ms\n * await delay('infinite') // delay response infinitely\n *\n * @see {@link https://mswjs.io/docs/api/delay `delay()` API reference}\n */\nexport async function delay(\n durationOrMode?: DelayMode | number,\n): Promise<void> {\n let delayTime: number\n\n if (typeof durationOrMode === 'string') {\n switch (durationOrMode) {\n case 'infinite': {\n // Using `Infinity` as a delay value executes the response timeout immediately.\n // Instead, use the maximum allowed integer for `setTimeout`.\n delayTime = SET_TIMEOUT_MAX_ALLOWED_INT\n break\n }\n case 'real': {\n delayTime = getRealisticResponseTime()\n break\n }\n default: {\n throw new Error(\n `Failed to delay a response: unknown delay mode \"${durationOrMode}\". Please make sure you provide one of the supported modes (\"real\", \"infinite\") or a number.`,\n )\n }\n }\n } else if (typeof durationOrMode === 'undefined') {\n // Use random realistic server response time when no explicit delay duration was provided.\n delayTime = getRealisticResponseTime()\n } else {\n // Guard against passing values like `Infinity` or `Number.MAX_VALUE`\n // as the response delay duration. They don't produce the result you may expect.\n if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {\n throw new Error(\n `Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for \"setTimeout\" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the \"infinite\" delay mode to delay the response indefinitely.`,\n )\n }\n\n delayTime = durationOrMode\n }\n\n return new Promise((resolve) => {\n const timeoutId = setTimeout(resolve, delayTime)\n\n if (\n delayTime === SET_TIMEOUT_MAX_ALLOWED_INT &&\n isNodeProcess() &&\n hasRefCounted(timeoutId)\n ) {\n // Prevent the process from hanging if this is the only active ref.\n timeoutId.unref()\n }\n })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,6BAA8B;AAC9B,2BAA8B;AAEvB,MAAM,8BAA8B;AACpC,MAAM,2BAA2B;AACjC,MAAM,2BAA2B;AACjC,MAAM,4BAA4B;AAEzC,SAAS,2BAAmC;AAC1C,UAAI,sCAAc,GAAG;AACnB,WAAO;AAAA,EACT;AAEA,SAAO,KAAK;AAAA,IACV,KAAK,OAAO,KAAK,2BAA2B,4BAC1C;AAAA,EACJ;AACF;AAcA,eAAsB,MACpB,gBACe;AACf,MAAI;AAEJ,MAAI,OAAO,mBAAmB,UAAU;AACtC,YAAQ,gBAAgB;AAAA,MACtB,KAAK,YAAY;AAGf,oBAAY;AACZ;AAAA,MACF;AAAA,MACA,KAAK,QAAQ;AACX,oBAAY,yBAAyB;AACrC;AAAA,MACF;AAAA,MACA,SAAS;AACP,cAAM,IAAI;AAAA,UACR,mDAAmD,cAAc;AAAA,QACnE;AAAA,MACF;AAAA,IACF;AAAA,EACF,WAAW,OAAO,mBAAmB,aAAa;AAEhD,gBAAY,yBAAyB;AAAA,EACvC,OAAO;AAGL,QAAI,iBAAiB,6BAA6B;AAChD,YAAM,IAAI;AAAA,QACR,wDAAwD,cAAc,4DAA4D,2BAA2B;AAAA,MAC/J;AAAA,IACF;AAEA,gBAAY;AAAA,EACd;AAEA,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,UAAM,YAAY,WAAW,SAAS,SAAS;AAE/C,QACE,cAAc,mCACd,sCAAc,SACd,oCAAc,SAAS,GACvB;AAEA,gBAAU,MAAM;AAAA,IAClB;AAAA,EACF,CAAC;AACH;","names":[]}

57
node_modules/msw/lib/core/delay.mjs generated vendored Normal file
View File

@@ -0,0 +1,57 @@
import { isNodeProcess } from "is-node-process";
import { hasRefCounted } from './utils/internal/hasRefCounted.mjs';
const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
const MIN_SERVER_RESPONSE_TIME = 100;
const MAX_SERVER_RESPONSE_TIME = 400;
const NODE_SERVER_RESPONSE_TIME = 5;
function getRealisticResponseTime() {
if (isNodeProcess()) {
return NODE_SERVER_RESPONSE_TIME;
}
return Math.floor(
Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) + MIN_SERVER_RESPONSE_TIME
);
}
async function delay(durationOrMode) {
let delayTime;
if (typeof durationOrMode === "string") {
switch (durationOrMode) {
case "infinite": {
delayTime = SET_TIMEOUT_MAX_ALLOWED_INT;
break;
}
case "real": {
delayTime = getRealisticResponseTime();
break;
}
default: {
throw new Error(
`Failed to delay a response: unknown delay mode "${durationOrMode}". Please make sure you provide one of the supported modes ("real", "infinite") or a number.`
);
}
}
} else if (typeof durationOrMode === "undefined") {
delayTime = getRealisticResponseTime();
} else {
if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {
throw new Error(
`Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for "setTimeout" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the "infinite" delay mode to delay the response indefinitely.`
);
}
delayTime = durationOrMode;
}
return new Promise((resolve) => {
const timeoutId = setTimeout(resolve, delayTime);
if (delayTime === SET_TIMEOUT_MAX_ALLOWED_INT && isNodeProcess() && hasRefCounted(timeoutId)) {
timeoutId.unref();
}
});
}
export {
MAX_SERVER_RESPONSE_TIME,
MIN_SERVER_RESPONSE_TIME,
NODE_SERVER_RESPONSE_TIME,
SET_TIMEOUT_MAX_ALLOWED_INT,
delay
};
//# sourceMappingURL=delay.mjs.map

1
node_modules/msw/lib/core/delay.mjs.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../src/core/delay.ts"],"sourcesContent":["import { isNodeProcess } from 'is-node-process'\nimport { hasRefCounted } from './utils/internal/hasRefCounted'\n\nexport const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647\nexport const MIN_SERVER_RESPONSE_TIME = 100\nexport const MAX_SERVER_RESPONSE_TIME = 400\nexport const NODE_SERVER_RESPONSE_TIME = 5\n\nfunction getRealisticResponseTime(): number {\n if (isNodeProcess()) {\n return NODE_SERVER_RESPONSE_TIME\n }\n\n return Math.floor(\n Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) +\n MIN_SERVER_RESPONSE_TIME,\n )\n}\n\nexport type DelayMode = 'real' | 'infinite'\n\n/**\n * Delays the response by the given duration (ms).\n *\n * @example\n * await delay() // emulate realistic server response time\n * await delay(1200) // delay response by 1200ms\n * await delay('infinite') // delay response infinitely\n *\n * @see {@link https://mswjs.io/docs/api/delay `delay()` API reference}\n */\nexport async function delay(\n durationOrMode?: DelayMode | number,\n): Promise<void> {\n let delayTime: number\n\n if (typeof durationOrMode === 'string') {\n switch (durationOrMode) {\n case 'infinite': {\n // Using `Infinity` as a delay value executes the response timeout immediately.\n // Instead, use the maximum allowed integer for `setTimeout`.\n delayTime = SET_TIMEOUT_MAX_ALLOWED_INT\n break\n }\n case 'real': {\n delayTime = getRealisticResponseTime()\n break\n }\n default: {\n throw new Error(\n `Failed to delay a response: unknown delay mode \"${durationOrMode}\". Please make sure you provide one of the supported modes (\"real\", \"infinite\") or a number.`,\n )\n }\n }\n } else if (typeof durationOrMode === 'undefined') {\n // Use random realistic server response time when no explicit delay duration was provided.\n delayTime = getRealisticResponseTime()\n } else {\n // Guard against passing values like `Infinity` or `Number.MAX_VALUE`\n // as the response delay duration. They don't produce the result you may expect.\n if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {\n throw new Error(\n `Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for \"setTimeout\" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the \"infinite\" delay mode to delay the response indefinitely.`,\n )\n }\n\n delayTime = durationOrMode\n }\n\n return new Promise((resolve) => {\n const timeoutId = setTimeout(resolve, delayTime)\n\n if (\n delayTime === SET_TIMEOUT_MAX_ALLOWED_INT &&\n isNodeProcess() &&\n hasRefCounted(timeoutId)\n ) {\n // Prevent the process from hanging if this is the only active ref.\n timeoutId.unref()\n }\n })\n}\n"],"mappings":"AAAA,SAAS,qBAAqB;AAC9B,SAAS,qBAAqB;AAEvB,MAAM,8BAA8B;AACpC,MAAM,2BAA2B;AACjC,MAAM,2BAA2B;AACjC,MAAM,4BAA4B;AAEzC,SAAS,2BAAmC;AAC1C,MAAI,cAAc,GAAG;AACnB,WAAO;AAAA,EACT;AAEA,SAAO,KAAK;AAAA,IACV,KAAK,OAAO,KAAK,2BAA2B,4BAC1C;AAAA,EACJ;AACF;AAcA,eAAsB,MACpB,gBACe;AACf,MAAI;AAEJ,MAAI,OAAO,mBAAmB,UAAU;AACtC,YAAQ,gBAAgB;AAAA,MACtB,KAAK,YAAY;AAGf,oBAAY;AACZ;AAAA,MACF;AAAA,MACA,KAAK,QAAQ;AACX,oBAAY,yBAAyB;AACrC;AAAA,MACF;AAAA,MACA,SAAS;AACP,cAAM,IAAI;AAAA,UACR,mDAAmD,cAAc;AAAA,QACnE;AAAA,MACF;AAAA,IACF;AAAA,EACF,WAAW,OAAO,mBAAmB,aAAa;AAEhD,gBAAY,yBAAyB;AAAA,EACvC,OAAO;AAGL,QAAI,iBAAiB,6BAA6B;AAChD,YAAM,IAAI;AAAA,QACR,wDAAwD,cAAc,4DAA4D,2BAA2B;AAAA,MAC/J;AAAA,IACF;AAEA,gBAAY;AAAA,EACd;AAEA,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,UAAM,YAAY,WAAW,SAAS,SAAS;AAE/C,QACE,cAAc,+BACd,cAAc,KACd,cAAc,SAAS,GACvB;AAEA,gBAAU,MAAM;AAAA,IAClB;AAAA,EACF,CAAC;AACH;","names":[]}

18
node_modules/msw/lib/core/getResponse.d.mts generated vendored Normal file
View File

@@ -0,0 +1,18 @@
import { R as RequestHandler, m as ResponseResolutionContext } from './HttpResponse-Be4eT3x6.mjs';
import '@mswjs/interceptors';
import './utils/internal/isIterable.mjs';
import './typeUtils.mjs';
import 'graphql';
import './utils/matching/matchRequestUrl.mjs';
/**
* Finds a response for the given request instance
* in the array of request handlers.
* @param handlers The array of request handlers.
* @param request The `Request` instance.
* @param resolutionContext Request resolution options.
* @returns {Response} A mocked response, if any.
*/
declare const getResponse: (handlers: Array<RequestHandler>, request: Request, resolutionContext?: ResponseResolutionContext) => Promise<Response | undefined>;
export { getResponse };

18
node_modules/msw/lib/core/getResponse.d.ts generated vendored Normal file
View File

@@ -0,0 +1,18 @@
import { R as RequestHandler, m as ResponseResolutionContext } from './HttpResponse-Dj6ibgFJ.js';
import '@mswjs/interceptors';
import './utils/internal/isIterable.js';
import './typeUtils.js';
import 'graphql';
import './utils/matching/matchRequestUrl.js';
/**
* Finds a response for the given request instance
* in the array of request handlers.
* @param handlers The array of request handlers.
* @param request The `Request` instance.
* @param resolutionContext Request resolution options.
* @returns {Response} A mocked response, if any.
*/
declare const getResponse: (handlers: Array<RequestHandler>, request: Request, resolutionContext?: ResponseResolutionContext) => Promise<Response | undefined>;
export { getResponse };

35
node_modules/msw/lib/core/getResponse.js generated vendored Normal file
View File

@@ -0,0 +1,35 @@
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var getResponse_exports = {};
__export(getResponse_exports, {
getResponse: () => getResponse
});
module.exports = __toCommonJS(getResponse_exports);
var import_interceptors = require("@mswjs/interceptors");
var import_executeHandlers = require("./utils/executeHandlers");
const getResponse = async (handlers, request, resolutionContext) => {
const result = await (0, import_executeHandlers.executeHandlers)({
request,
requestId: (0, import_interceptors.createRequestId)(),
handlers,
resolutionContext
});
return result?.response;
};
//# sourceMappingURL=getResponse.js.map

1
node_modules/msw/lib/core/getResponse.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../src/core/getResponse.ts"],"sourcesContent":["import { createRequestId } from '@mswjs/interceptors'\nimport type { RequestHandler } from './handlers/RequestHandler'\nimport {\n executeHandlers,\n type ResponseResolutionContext,\n} from './utils/executeHandlers'\n\n/**\n * Finds a response for the given request instance\n * in the array of request handlers.\n * @param handlers The array of request handlers.\n * @param request The `Request` instance.\n * @param resolutionContext Request resolution options.\n * @returns {Response} A mocked response, if any.\n */\nexport const getResponse = async (\n handlers: Array<RequestHandler>,\n request: Request,\n resolutionContext?: ResponseResolutionContext,\n): Promise<Response | undefined> => {\n const result = await executeHandlers({\n request,\n requestId: createRequestId(),\n handlers,\n resolutionContext,\n })\n\n return result?.response\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0BAAgC;AAEhC,6BAGO;AAUA,MAAM,cAAc,OACzB,UACA,SACA,sBACkC;AAClC,QAAM,SAAS,UAAM,wCAAgB;AAAA,IACnC;AAAA,IACA,eAAW,qCAAgB;AAAA,IAC3B;AAAA,IACA;AAAA,EACF,CAAC;AAED,SAAO,QAAQ;AACjB;","names":[]}

17
node_modules/msw/lib/core/getResponse.mjs generated vendored Normal file
View File

@@ -0,0 +1,17 @@
import { createRequestId } from "@mswjs/interceptors";
import {
executeHandlers
} from './utils/executeHandlers.mjs';
const getResponse = async (handlers, request, resolutionContext) => {
const result = await executeHandlers({
request,
requestId: createRequestId(),
handlers,
resolutionContext
});
return result?.response;
};
export {
getResponse
};
//# sourceMappingURL=getResponse.mjs.map

1
node_modules/msw/lib/core/getResponse.mjs.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../src/core/getResponse.ts"],"sourcesContent":["import { createRequestId } from '@mswjs/interceptors'\nimport type { RequestHandler } from './handlers/RequestHandler'\nimport {\n executeHandlers,\n type ResponseResolutionContext,\n} from './utils/executeHandlers'\n\n/**\n * Finds a response for the given request instance\n * in the array of request handlers.\n * @param handlers The array of request handlers.\n * @param request The `Request` instance.\n * @param resolutionContext Request resolution options.\n * @returns {Response} A mocked response, if any.\n */\nexport const getResponse = async (\n handlers: Array<RequestHandler>,\n request: Request,\n resolutionContext?: ResponseResolutionContext,\n): Promise<Response | undefined> => {\n const result = await executeHandlers({\n request,\n requestId: createRequestId(),\n handlers,\n resolutionContext,\n })\n\n return result?.response\n}\n"],"mappings":"AAAA,SAAS,uBAAuB;AAEhC;AAAA,EACE;AAAA,OAEK;AAUA,MAAM,cAAc,OACzB,UACA,SACA,sBACkC;AAClC,QAAM,SAAS,MAAM,gBAAgB;AAAA,IACnC;AAAA,IACA,WAAW,gBAAgB;AAAA,IAC3B;AAAA,IACA;AAAA,EACF,CAAC;AAED,SAAO,QAAQ;AACjB;","names":[]}

76
node_modules/msw/lib/core/graphql.d.mts generated vendored Normal file
View File

@@ -0,0 +1,76 @@
import { f as GraphQLQuery, g as GraphQLVariables, p as GraphQLPredicate, a as ResponseResolver, q as GraphQLResolverExtras, i as GraphQLResponseBody, c as RequestHandlerOptions, G as GraphQLHandler } from './HttpResponse-Be4eT3x6.mjs';
import { Path } from './utils/matching/matchRequestUrl.mjs';
import '@mswjs/interceptors';
import './utils/internal/isIterable.mjs';
import './typeUtils.mjs';
import 'graphql';
type GraphQLRequestHandler = <Query extends GraphQLQuery = GraphQLQuery, Variables extends GraphQLVariables = GraphQLVariables>(predicate: GraphQLPredicate<Query, Variables>, resolver: GraphQLResponseResolver<[
Query
] extends [never] ? GraphQLQuery : Query, Variables>, options?: RequestHandlerOptions) => GraphQLHandler;
type GraphQLOperationHandler = <Query extends GraphQLQuery = GraphQLQuery, Variables extends GraphQLVariables = GraphQLVariables>(resolver: GraphQLResponseResolver<[
Query
] extends [never] ? GraphQLQuery : Query, Variables>, options?: RequestHandlerOptions) => GraphQLHandler;
type GraphQLResponseResolver<Query extends GraphQLQuery = GraphQLQuery, Variables extends GraphQLVariables = GraphQLVariables> = ResponseResolver<GraphQLResolverExtras<Variables>, null, GraphQLResponseBody<[Query] extends [never] ? GraphQLQuery : Query>>;
interface GraphQLLinkHandlers {
query: GraphQLRequestHandler;
mutation: GraphQLRequestHandler;
operation: GraphQLOperationHandler;
}
/**
* A namespace to intercept and mock GraphQL operations
*
* @example
* graphql.query('GetUser', resolver)
* graphql.mutation('DeletePost', resolver)
*
* @see {@link https://mswjs.io/docs/api/graphql `graphql` API reference}
*/
declare const graphql: {
/**
* Intercepts a GraphQL query by a given name.
*
* @example
* graphql.query('GetUser', () => {
* return HttpResponse.json({ data: { user: { name: 'John' } } })
* })
*
* @see {@link https://mswjs.io/docs/api/graphql#graphqlqueryqueryname-resolver `graphql.query()` API reference}
*/
query: GraphQLRequestHandler;
/**
* Intercepts a GraphQL mutation by its name.
*
* @example
* graphql.mutation('SavePost', () => {
* return HttpResponse.json({ data: { post: { id: 'abc-123 } } })
* })
*
* @see {@link https://mswjs.io/docs/api/graphql#graphqlmutationmutationname-resolver `graphql.query()` API reference}
*
*/
mutation: GraphQLRequestHandler;
/**
* Intercepts any GraphQL operation, regardless of its type or name.
*
* @example
* graphql.operation(() => {
* return HttpResponse.json({ data: { name: 'John' } })
* })
*
* @see {@link https://mswjs.io/docs/api/graphql#graphqloperationresolver `graphql.operation()` API reference}
*/
operation: GraphQLOperationHandler;
/**
* Intercepts GraphQL operations scoped by the given URL.
*
* @example
* const github = graphql.link('https://api.github.com/graphql')
* github.query('GetRepo', resolver)
*
* @see {@link https://mswjs.io/docs/api/graphql#graphqllinkurl `graphql.link()` API reference}
*/
link(url: Path): GraphQLLinkHandlers;
};
export { type GraphQLLinkHandlers, type GraphQLOperationHandler, type GraphQLRequestHandler, type GraphQLResponseResolver, graphql };

76
node_modules/msw/lib/core/graphql.d.ts generated vendored Normal file
View File

@@ -0,0 +1,76 @@
import { f as GraphQLQuery, g as GraphQLVariables, p as GraphQLPredicate, a as ResponseResolver, q as GraphQLResolverExtras, i as GraphQLResponseBody, c as RequestHandlerOptions, G as GraphQLHandler } from './HttpResponse-Dj6ibgFJ.js';
import { Path } from './utils/matching/matchRequestUrl.js';
import '@mswjs/interceptors';
import './utils/internal/isIterable.js';
import './typeUtils.js';
import 'graphql';
type GraphQLRequestHandler = <Query extends GraphQLQuery = GraphQLQuery, Variables extends GraphQLVariables = GraphQLVariables>(predicate: GraphQLPredicate<Query, Variables>, resolver: GraphQLResponseResolver<[
Query
] extends [never] ? GraphQLQuery : Query, Variables>, options?: RequestHandlerOptions) => GraphQLHandler;
type GraphQLOperationHandler = <Query extends GraphQLQuery = GraphQLQuery, Variables extends GraphQLVariables = GraphQLVariables>(resolver: GraphQLResponseResolver<[
Query
] extends [never] ? GraphQLQuery : Query, Variables>, options?: RequestHandlerOptions) => GraphQLHandler;
type GraphQLResponseResolver<Query extends GraphQLQuery = GraphQLQuery, Variables extends GraphQLVariables = GraphQLVariables> = ResponseResolver<GraphQLResolverExtras<Variables>, null, GraphQLResponseBody<[Query] extends [never] ? GraphQLQuery : Query>>;
interface GraphQLLinkHandlers {
query: GraphQLRequestHandler;
mutation: GraphQLRequestHandler;
operation: GraphQLOperationHandler;
}
/**
* A namespace to intercept and mock GraphQL operations
*
* @example
* graphql.query('GetUser', resolver)
* graphql.mutation('DeletePost', resolver)
*
* @see {@link https://mswjs.io/docs/api/graphql `graphql` API reference}
*/
declare const graphql: {
/**
* Intercepts a GraphQL query by a given name.
*
* @example
* graphql.query('GetUser', () => {
* return HttpResponse.json({ data: { user: { name: 'John' } } })
* })
*
* @see {@link https://mswjs.io/docs/api/graphql#graphqlqueryqueryname-resolver `graphql.query()` API reference}
*/
query: GraphQLRequestHandler;
/**
* Intercepts a GraphQL mutation by its name.
*
* @example
* graphql.mutation('SavePost', () => {
* return HttpResponse.json({ data: { post: { id: 'abc-123 } } })
* })
*
* @see {@link https://mswjs.io/docs/api/graphql#graphqlmutationmutationname-resolver `graphql.query()` API reference}
*
*/
mutation: GraphQLRequestHandler;
/**
* Intercepts any GraphQL operation, regardless of its type or name.
*
* @example
* graphql.operation(() => {
* return HttpResponse.json({ data: { name: 'John' } })
* })
*
* @see {@link https://mswjs.io/docs/api/graphql#graphqloperationresolver `graphql.operation()` API reference}
*/
operation: GraphQLOperationHandler;
/**
* Intercepts GraphQL operations scoped by the given URL.
*
* @example
* const github = graphql.link('https://api.github.com/graphql')
* github.query('GetRepo', resolver)
*
* @see {@link https://mswjs.io/docs/api/graphql#graphqllinkurl `graphql.link()` API reference}
*/
link(url: Path): GraphQLLinkHandlers;
};
export { type GraphQLLinkHandlers, type GraphQLOperationHandler, type GraphQLRequestHandler, type GraphQLResponseResolver, graphql };

90
node_modules/msw/lib/core/graphql.js generated vendored Normal file
View File

@@ -0,0 +1,90 @@
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var graphql_exports = {};
__export(graphql_exports, {
graphql: () => graphql
});
module.exports = __toCommonJS(graphql_exports);
var import_GraphQLHandler = require("./handlers/GraphQLHandler");
function createScopedGraphQLHandler(operationType, url) {
return (predicate, resolver, options = {}) => {
return new import_GraphQLHandler.GraphQLHandler(operationType, predicate, url, resolver, options);
};
}
function createGraphQLOperationHandler(url) {
return (resolver, options) => {
return new import_GraphQLHandler.GraphQLHandler("all", new RegExp(".*"), url, resolver, options);
};
}
const graphql = {
/**
* Intercepts a GraphQL query by a given name.
*
* @example
* graphql.query('GetUser', () => {
* return HttpResponse.json({ data: { user: { name: 'John' } } })
* })
*
* @see {@link https://mswjs.io/docs/api/graphql#graphqlqueryqueryname-resolver `graphql.query()` API reference}
*/
query: createScopedGraphQLHandler("query", "*"),
/**
* Intercepts a GraphQL mutation by its name.
*
* @example
* graphql.mutation('SavePost', () => {
* return HttpResponse.json({ data: { post: { id: 'abc-123 } } })
* })
*
* @see {@link https://mswjs.io/docs/api/graphql#graphqlmutationmutationname-resolver `graphql.query()` API reference}
*
*/
mutation: createScopedGraphQLHandler("mutation", "*"),
/**
* Intercepts any GraphQL operation, regardless of its type or name.
*
* @example
* graphql.operation(() => {
* return HttpResponse.json({ data: { name: 'John' } })
* })
*
* @see {@link https://mswjs.io/docs/api/graphql#graphqloperationresolver `graphql.operation()` API reference}
*/
operation: createGraphQLOperationHandler("*"),
/**
* Intercepts GraphQL operations scoped by the given URL.
*
* @example
* const github = graphql.link('https://api.github.com/graphql')
* github.query('GetRepo', resolver)
*
* @see {@link https://mswjs.io/docs/api/graphql#graphqllinkurl `graphql.link()` API reference}
*/
link(url) {
return {
operation: createGraphQLOperationHandler(url),
query: createScopedGraphQLHandler("query", url),
mutation: createScopedGraphQLHandler(
"mutation",
url
)
};
}
};
//# sourceMappingURL=graphql.js.map

1
node_modules/msw/lib/core/graphql.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../src/core/graphql.ts"],"sourcesContent":["import type { OperationTypeNode } from 'graphql'\nimport {\n ResponseResolver,\n RequestHandlerOptions,\n} from './handlers/RequestHandler'\nimport {\n GraphQLHandler,\n GraphQLVariables,\n GraphQLOperationType,\n GraphQLResolverExtras,\n GraphQLResponseBody,\n GraphQLQuery,\n GraphQLPredicate,\n} from './handlers/GraphQLHandler'\nimport type { Path } from './utils/matching/matchRequestUrl'\n\nexport type GraphQLRequestHandler = <\n Query extends GraphQLQuery = GraphQLQuery,\n Variables extends GraphQLVariables = GraphQLVariables,\n>(\n predicate: GraphQLPredicate<Query, Variables>,\n resolver: GraphQLResponseResolver<\n [Query] extends [never] ? GraphQLQuery : Query,\n Variables\n >,\n options?: RequestHandlerOptions,\n) => GraphQLHandler\n\nexport type GraphQLOperationHandler = <\n Query extends GraphQLQuery = GraphQLQuery,\n Variables extends GraphQLVariables = GraphQLVariables,\n>(\n resolver: GraphQLResponseResolver<\n [Query] extends [never] ? GraphQLQuery : Query,\n Variables\n >,\n options?: RequestHandlerOptions,\n) => GraphQLHandler\n\nexport type GraphQLResponseResolver<\n Query extends GraphQLQuery = GraphQLQuery,\n Variables extends GraphQLVariables = GraphQLVariables,\n> = ResponseResolver<\n GraphQLResolverExtras<Variables>,\n null,\n GraphQLResponseBody<[Query] extends [never] ? GraphQLQuery : Query>\n>\n\nfunction createScopedGraphQLHandler(\n operationType: GraphQLOperationType,\n url: Path,\n): GraphQLRequestHandler {\n return (predicate, resolver, options = {}) => {\n return new GraphQLHandler(operationType, predicate, url, resolver, options)\n }\n}\n\nfunction createGraphQLOperationHandler(url: Path): GraphQLOperationHandler {\n return (resolver, options) => {\n return new GraphQLHandler('all', new RegExp('.*'), url, resolver, options)\n }\n}\n\nexport interface GraphQLLinkHandlers {\n query: GraphQLRequestHandler\n mutation: GraphQLRequestHandler\n operation: GraphQLOperationHandler\n}\n\n/**\n * A namespace to intercept and mock GraphQL operations\n *\n * @example\n * graphql.query('GetUser', resolver)\n * graphql.mutation('DeletePost', resolver)\n *\n * @see {@link https://mswjs.io/docs/api/graphql `graphql` API reference}\n */\nexport const graphql = {\n /**\n * Intercepts a GraphQL query by a given name.\n *\n * @example\n * graphql.query('GetUser', () => {\n * return HttpResponse.json({ data: { user: { name: 'John' } } })\n * })\n *\n * @see {@link https://mswjs.io/docs/api/graphql#graphqlqueryqueryname-resolver `graphql.query()` API reference}\n */\n query: createScopedGraphQLHandler('query' as OperationTypeNode, '*'),\n\n /**\n * Intercepts a GraphQL mutation by its name.\n *\n * @example\n * graphql.mutation('SavePost', () => {\n * return HttpResponse.json({ data: { post: { id: 'abc-123 } } })\n * })\n *\n * @see {@link https://mswjs.io/docs/api/graphql#graphqlmutationmutationname-resolver `graphql.query()` API reference}\n *\n */\n mutation: createScopedGraphQLHandler('mutation' as OperationTypeNode, '*'),\n\n /**\n * Intercepts any GraphQL operation, regardless of its type or name.\n *\n * @example\n * graphql.operation(() => {\n * return HttpResponse.json({ data: { name: 'John' } })\n * })\n *\n * @see {@link https://mswjs.io/docs/api/graphql#graphqloperationresolver `graphql.operation()` API reference}\n */\n operation: createGraphQLOperationHandler('*'),\n\n /**\n * Intercepts GraphQL operations scoped by the given URL.\n *\n * @example\n * const github = graphql.link('https://api.github.com/graphql')\n * github.query('GetRepo', resolver)\n *\n * @see {@link https://mswjs.io/docs/api/graphql#graphqllinkurl `graphql.link()` API reference}\n */\n link(url: Path): GraphQLLinkHandlers {\n return {\n operation: createGraphQLOperationHandler(url),\n query: createScopedGraphQLHandler('query' as OperationTypeNode, url),\n mutation: createScopedGraphQLHandler(\n 'mutation' as OperationTypeNode,\n url,\n ),\n }\n },\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,4BAQO;AAmCP,SAAS,2BACP,eACA,KACuB;AACvB,SAAO,CAAC,WAAW,UAAU,UAAU,CAAC,MAAM;AAC5C,WAAO,IAAI,qCAAe,eAAe,WAAW,KAAK,UAAU,OAAO;AAAA,EAC5E;AACF;AAEA,SAAS,8BAA8B,KAAoC;AACzE,SAAO,CAAC,UAAU,YAAY;AAC5B,WAAO,IAAI,qCAAe,OAAO,IAAI,OAAO,IAAI,GAAG,KAAK,UAAU,OAAO;AAAA,EAC3E;AACF;AAiBO,MAAM,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWrB,OAAO,2BAA2B,SAA8B,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAanE,UAAU,2BAA2B,YAAiC,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYzE,WAAW,8BAA8B,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAW5C,KAAK,KAAgC;AACnC,WAAO;AAAA,MACL,WAAW,8BAA8B,GAAG;AAAA,MAC5C,OAAO,2BAA2B,SAA8B,GAAG;AAAA,MACnE,UAAU;AAAA,QACR;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

72
node_modules/msw/lib/core/graphql.mjs generated vendored Normal file
View File

@@ -0,0 +1,72 @@
import {
GraphQLHandler
} from './handlers/GraphQLHandler.mjs';
function createScopedGraphQLHandler(operationType, url) {
return (predicate, resolver, options = {}) => {
return new GraphQLHandler(operationType, predicate, url, resolver, options);
};
}
function createGraphQLOperationHandler(url) {
return (resolver, options) => {
return new GraphQLHandler("all", new RegExp(".*"), url, resolver, options);
};
}
const graphql = {
/**
* Intercepts a GraphQL query by a given name.
*
* @example
* graphql.query('GetUser', () => {
* return HttpResponse.json({ data: { user: { name: 'John' } } })
* })
*
* @see {@link https://mswjs.io/docs/api/graphql#graphqlqueryqueryname-resolver `graphql.query()` API reference}
*/
query: createScopedGraphQLHandler("query", "*"),
/**
* Intercepts a GraphQL mutation by its name.
*
* @example
* graphql.mutation('SavePost', () => {
* return HttpResponse.json({ data: { post: { id: 'abc-123 } } })
* })
*
* @see {@link https://mswjs.io/docs/api/graphql#graphqlmutationmutationname-resolver `graphql.query()` API reference}
*
*/
mutation: createScopedGraphQLHandler("mutation", "*"),
/**
* Intercepts any GraphQL operation, regardless of its type or name.
*
* @example
* graphql.operation(() => {
* return HttpResponse.json({ data: { name: 'John' } })
* })
*
* @see {@link https://mswjs.io/docs/api/graphql#graphqloperationresolver `graphql.operation()` API reference}
*/
operation: createGraphQLOperationHandler("*"),
/**
* Intercepts GraphQL operations scoped by the given URL.
*
* @example
* const github = graphql.link('https://api.github.com/graphql')
* github.query('GetRepo', resolver)
*
* @see {@link https://mswjs.io/docs/api/graphql#graphqllinkurl `graphql.link()` API reference}
*/
link(url) {
return {
operation: createGraphQLOperationHandler(url),
query: createScopedGraphQLHandler("query", url),
mutation: createScopedGraphQLHandler(
"mutation",
url
)
};
}
};
export {
graphql
};
//# sourceMappingURL=graphql.mjs.map

1
node_modules/msw/lib/core/graphql.mjs.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../src/core/graphql.ts"],"sourcesContent":["import type { OperationTypeNode } from 'graphql'\nimport {\n ResponseResolver,\n RequestHandlerOptions,\n} from './handlers/RequestHandler'\nimport {\n GraphQLHandler,\n GraphQLVariables,\n GraphQLOperationType,\n GraphQLResolverExtras,\n GraphQLResponseBody,\n GraphQLQuery,\n GraphQLPredicate,\n} from './handlers/GraphQLHandler'\nimport type { Path } from './utils/matching/matchRequestUrl'\n\nexport type GraphQLRequestHandler = <\n Query extends GraphQLQuery = GraphQLQuery,\n Variables extends GraphQLVariables = GraphQLVariables,\n>(\n predicate: GraphQLPredicate<Query, Variables>,\n resolver: GraphQLResponseResolver<\n [Query] extends [never] ? GraphQLQuery : Query,\n Variables\n >,\n options?: RequestHandlerOptions,\n) => GraphQLHandler\n\nexport type GraphQLOperationHandler = <\n Query extends GraphQLQuery = GraphQLQuery,\n Variables extends GraphQLVariables = GraphQLVariables,\n>(\n resolver: GraphQLResponseResolver<\n [Query] extends [never] ? GraphQLQuery : Query,\n Variables\n >,\n options?: RequestHandlerOptions,\n) => GraphQLHandler\n\nexport type GraphQLResponseResolver<\n Query extends GraphQLQuery = GraphQLQuery,\n Variables extends GraphQLVariables = GraphQLVariables,\n> = ResponseResolver<\n GraphQLResolverExtras<Variables>,\n null,\n GraphQLResponseBody<[Query] extends [never] ? GraphQLQuery : Query>\n>\n\nfunction createScopedGraphQLHandler(\n operationType: GraphQLOperationType,\n url: Path,\n): GraphQLRequestHandler {\n return (predicate, resolver, options = {}) => {\n return new GraphQLHandler(operationType, predicate, url, resolver, options)\n }\n}\n\nfunction createGraphQLOperationHandler(url: Path): GraphQLOperationHandler {\n return (resolver, options) => {\n return new GraphQLHandler('all', new RegExp('.*'), url, resolver, options)\n }\n}\n\nexport interface GraphQLLinkHandlers {\n query: GraphQLRequestHandler\n mutation: GraphQLRequestHandler\n operation: GraphQLOperationHandler\n}\n\n/**\n * A namespace to intercept and mock GraphQL operations\n *\n * @example\n * graphql.query('GetUser', resolver)\n * graphql.mutation('DeletePost', resolver)\n *\n * @see {@link https://mswjs.io/docs/api/graphql `graphql` API reference}\n */\nexport const graphql = {\n /**\n * Intercepts a GraphQL query by a given name.\n *\n * @example\n * graphql.query('GetUser', () => {\n * return HttpResponse.json({ data: { user: { name: 'John' } } })\n * })\n *\n * @see {@link https://mswjs.io/docs/api/graphql#graphqlqueryqueryname-resolver `graphql.query()` API reference}\n */\n query: createScopedGraphQLHandler('query' as OperationTypeNode, '*'),\n\n /**\n * Intercepts a GraphQL mutation by its name.\n *\n * @example\n * graphql.mutation('SavePost', () => {\n * return HttpResponse.json({ data: { post: { id: 'abc-123 } } })\n * })\n *\n * @see {@link https://mswjs.io/docs/api/graphql#graphqlmutationmutationname-resolver `graphql.query()` API reference}\n *\n */\n mutation: createScopedGraphQLHandler('mutation' as OperationTypeNode, '*'),\n\n /**\n * Intercepts any GraphQL operation, regardless of its type or name.\n *\n * @example\n * graphql.operation(() => {\n * return HttpResponse.json({ data: { name: 'John' } })\n * })\n *\n * @see {@link https://mswjs.io/docs/api/graphql#graphqloperationresolver `graphql.operation()` API reference}\n */\n operation: createGraphQLOperationHandler('*'),\n\n /**\n * Intercepts GraphQL operations scoped by the given URL.\n *\n * @example\n * const github = graphql.link('https://api.github.com/graphql')\n * github.query('GetRepo', resolver)\n *\n * @see {@link https://mswjs.io/docs/api/graphql#graphqllinkurl `graphql.link()` API reference}\n */\n link(url: Path): GraphQLLinkHandlers {\n return {\n operation: createGraphQLOperationHandler(url),\n query: createScopedGraphQLHandler('query' as OperationTypeNode, url),\n mutation: createScopedGraphQLHandler(\n 'mutation' as OperationTypeNode,\n url,\n ),\n }\n },\n}\n"],"mappings":"AAKA;AAAA,EACE;AAAA,OAOK;AAmCP,SAAS,2BACP,eACA,KACuB;AACvB,SAAO,CAAC,WAAW,UAAU,UAAU,CAAC,MAAM;AAC5C,WAAO,IAAI,eAAe,eAAe,WAAW,KAAK,UAAU,OAAO;AAAA,EAC5E;AACF;AAEA,SAAS,8BAA8B,KAAoC;AACzE,SAAO,CAAC,UAAU,YAAY;AAC5B,WAAO,IAAI,eAAe,OAAO,IAAI,OAAO,IAAI,GAAG,KAAK,UAAU,OAAO;AAAA,EAC3E;AACF;AAiBO,MAAM,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWrB,OAAO,2BAA2B,SAA8B,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAanE,UAAU,2BAA2B,YAAiC,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYzE,WAAW,8BAA8B,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAW5C,KAAK,KAAgC;AACnC,WAAO;AAAA,MACL,WAAW,8BAA8B,GAAG;AAAA,MAC5C,OAAO,2BAA2B,SAA8B,GAAG;AAAA,MACnE,UAAU;AAAA,QACR;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

View File

@@ -0,0 +1,6 @@
import 'graphql';
export { z as DocumentTypeDecoration, l as GraphQLCustomPredicate, F as GraphQLCustomPredicateResult, G as GraphQLHandler, C as GraphQLHandlerInfo, B as GraphQLHandlerNameSelector, j as GraphQLJsonRequestBody, k as GraphQLOperationType, p as GraphQLPredicate, f as GraphQLQuery, h as GraphQLRequestBody, E as GraphQLRequestParsedResult, q as GraphQLResolverExtras, i as GraphQLResponseBody, g as GraphQLVariables, I as isDocumentNode } from '../HttpResponse-Be4eT3x6.mjs';
import '../utils/matching/matchRequestUrl.mjs';
import '@mswjs/interceptors';
import '../utils/internal/isIterable.mjs';
import '../typeUtils.mjs';

View File

@@ -0,0 +1,6 @@
import 'graphql';
export { z as DocumentTypeDecoration, l as GraphQLCustomPredicate, F as GraphQLCustomPredicateResult, G as GraphQLHandler, C as GraphQLHandlerInfo, B as GraphQLHandlerNameSelector, j as GraphQLJsonRequestBody, k as GraphQLOperationType, p as GraphQLPredicate, f as GraphQLQuery, h as GraphQLRequestBody, E as GraphQLRequestParsedResult, q as GraphQLResolverExtras, i as GraphQLResponseBody, g as GraphQLVariables, I as isDocumentNode } from '../HttpResponse-Dj6ibgFJ.js';
import '../utils/matching/matchRequestUrl.js';
import '@mswjs/interceptors';
import '../utils/internal/isIterable.js';
import '../typeUtils.js';

231
node_modules/msw/lib/core/handlers/GraphQLHandler.js generated vendored Normal file
View File

@@ -0,0 +1,231 @@
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var GraphQLHandler_exports = {};
__export(GraphQLHandler_exports, {
GraphQLHandler: () => GraphQLHandler,
isDocumentNode: () => isDocumentNode
});
module.exports = __toCommonJS(GraphQLHandler_exports);
var import_outvariant = require("outvariant");
var import_graphql = require("graphql");
var import_RequestHandler = require("./RequestHandler");
var import_getTimestamp = require("../utils/logging/getTimestamp");
var import_getStatusCodeColor = require("../utils/logging/getStatusCodeColor");
var import_serializeRequest = require("../utils/logging/serializeRequest");
var import_serializeResponse = require("../utils/logging/serializeResponse");
var import_matchRequestUrl = require("../utils/matching/matchRequestUrl");
var import_parseGraphQLRequest = require("../utils/internal/parseGraphQLRequest");
var import_toPublicUrl = require("../utils/request/toPublicUrl");
var import_devUtils = require("../utils/internal/devUtils");
var import_getRequestCookies = require("../utils/request/getRequestCookies");
var import_HttpResponse = require("../HttpResponse");
var import_getAllAcceptedMimeTypes = require("../utils/request/getAllAcceptedMimeTypes");
function isDocumentNode(value) {
if (value == null) {
return false;
}
return typeof value === "object" && "kind" in value && "definitions" in value;
}
function isDocumentTypeDecoration(value) {
return value instanceof String;
}
class GraphQLHandler extends import_RequestHandler.RequestHandler {
endpoint;
static parsedRequestCache = /* @__PURE__ */ new WeakMap();
static #parseOperationName(predicate, operationType) {
const getOperationName = (node) => {
(0, import_outvariant.invariant)(
node.operationType === operationType,
'Failed to create a GraphQL handler: provided a DocumentNode with a mismatched operation type (expected "%s" but got "%s").',
operationType,
node.operationType
);
(0, import_outvariant.invariant)(
node.operationName,
"Failed to create a GraphQL handler: provided a DocumentNode without operation name"
);
return node.operationName;
};
if (isDocumentNode(predicate)) {
return getOperationName((0, import_parseGraphQLRequest.parseDocumentNode)(predicate));
}
if (isDocumentTypeDecoration(predicate)) {
const documentNode = (0, import_graphql.parse)(predicate.toString());
(0, import_outvariant.invariant)(
isDocumentNode(documentNode),
"Failed to create a GraphQL handler: given TypedDocumentString (%s) does not produce a valid DocumentNode",
predicate
);
return getOperationName((0, import_parseGraphQLRequest.parseDocumentNode)(documentNode));
}
return predicate;
}
constructor(operationType, predicate, endpoint, resolver, options) {
const operationName = GraphQLHandler.#parseOperationName(
predicate,
operationType
);
const displayOperationName = typeof operationName === "function" ? "[custom predicate]" : operationName;
const header = operationType === "all" ? `${operationType} (origin: ${endpoint.toString()})` : `${operationType}${displayOperationName ? ` ${displayOperationName}` : ""} (origin: ${endpoint.toString()})`;
super({
info: {
header,
operationType,
operationName: GraphQLHandler.#parseOperationName(
predicate,
operationType
)
},
resolver,
options
});
this.endpoint = endpoint;
}
/**
* Parses the request body, once per request, cached across all
* GraphQL handlers. This is done to avoid multiple parsing of the
* request body, which each requires a clone of the request.
*/
async parseGraphQLRequestOrGetFromCache(request) {
if (!GraphQLHandler.parsedRequestCache.has(request)) {
GraphQLHandler.parsedRequestCache.set(
request,
await (0, import_parseGraphQLRequest.parseGraphQLRequest)(request).catch((error) => {
console.error(error);
return void 0;
})
);
}
return GraphQLHandler.parsedRequestCache.get(request);
}
async parse(args) {
const match = (0, import_matchRequestUrl.matchRequestUrl)(new URL(args.request.url), this.endpoint);
const cookies = (0, import_getRequestCookies.getAllRequestCookies)(args.request);
if (!match.matches) {
return {
match,
cookies
};
}
const parsedResult = await this.parseGraphQLRequestOrGetFromCache(
args.request
);
if (typeof parsedResult === "undefined") {
return {
match,
cookies
};
}
return {
match,
cookies,
query: parsedResult.query,
operationType: parsedResult.operationType,
operationName: parsedResult.operationName,
variables: parsedResult.variables
};
}
async predicate(args) {
if (args.parsedResult.operationType === void 0) {
return false;
}
if (!args.parsedResult.operationName && this.info.operationType !== "all") {
const publicUrl = (0, import_toPublicUrl.toPublicUrl)(args.request.url);
import_devUtils.devUtils.warn(`Failed to intercept a GraphQL request at "${args.request.method} ${publicUrl}": anonymous GraphQL operations are not supported.
Consider naming this operation or using "graphql.operation()" request handler to intercept GraphQL requests regardless of their operation name/type. Read more: https://mswjs.io/docs/api/graphql/#graphqloperationresolver`);
return false;
}
const hasMatchingOperationType = this.info.operationType === "all" || args.parsedResult.operationType === this.info.operationType;
const hasMatchingOperationName = await this.matchOperationName({
request: args.request,
parsedResult: args.parsedResult
});
return args.parsedResult.match.matches && hasMatchingOperationType && hasMatchingOperationName;
}
async run(args) {
const result = await super.run(args);
if (result?.response == null) {
return result;
}
if (!(import_HttpResponse.kDefaultContentType in result.response)) {
return result;
}
const acceptedMimeTypes = (0, import_getAllAcceptedMimeTypes.getAllAcceptedMimeTypes)(
args.request.headers.get("accept")
);
if (acceptedMimeTypes.length === 0) {
return result;
}
const graphqlResponseIndex = acceptedMimeTypes.indexOf(
"application/graphql-response+json"
);
const jsonIndex = acceptedMimeTypes.indexOf("application/json");
if (graphqlResponseIndex !== -1 && (jsonIndex === -1 || graphqlResponseIndex <= jsonIndex)) {
result.response.headers.set(
"content-type",
"application/graphql-response+json"
);
}
return result;
}
async matchOperationName(args) {
if (typeof this.info.operationName === "function") {
const customPredicateResult = await this.info.operationName({
request: args.request,
...this.extendResolverArgs({
request: args.request,
parsedResult: args.parsedResult
})
});
return typeof customPredicateResult === "boolean" ? customPredicateResult : customPredicateResult.matches;
}
if (this.info.operationName instanceof RegExp) {
return this.info.operationName.test(args.parsedResult.operationName || "");
}
return args.parsedResult.operationName === this.info.operationName;
}
extendResolverArgs(args) {
return {
query: args.parsedResult.query || "",
operationType: args.parsedResult.operationType,
operationName: args.parsedResult.operationName || "",
variables: args.parsedResult.variables || {},
cookies: args.parsedResult.cookies
};
}
async log(args) {
const loggedRequest = await (0, import_serializeRequest.serializeRequest)(args.request);
const loggedResponse = await (0, import_serializeResponse.serializeResponse)(args.response);
const statusColor = (0, import_getStatusCodeColor.getStatusCodeColor)(loggedResponse.status);
const requestInfo = args.parsedResult.operationName ? `${args.parsedResult.operationType} ${args.parsedResult.operationName}` : `anonymous ${args.parsedResult.operationType}`;
console.groupCollapsed(
import_devUtils.devUtils.formatMessage(
`${(0, import_getTimestamp.getTimestamp)()} ${requestInfo} (%c${loggedResponse.status} ${loggedResponse.statusText}%c)`
),
`color:${statusColor}`,
"color:inherit"
);
console.log("Request:", loggedRequest);
console.log("Handler:", this);
console.log("Response:", loggedResponse);
console.groupEnd();
}
}
//# sourceMappingURL=GraphQLHandler.js.map

File diff suppressed because one or more lines are too long

218
node_modules/msw/lib/core/handlers/GraphQLHandler.mjs generated vendored Normal file
View File

@@ -0,0 +1,218 @@
import { invariant } from "outvariant";
import {
parse
} from "graphql";
import {
RequestHandler
} from './RequestHandler.mjs';
import { getTimestamp } from '../utils/logging/getTimestamp.mjs';
import { getStatusCodeColor } from '../utils/logging/getStatusCodeColor.mjs';
import { serializeRequest } from '../utils/logging/serializeRequest.mjs';
import { serializeResponse } from '../utils/logging/serializeResponse.mjs';
import { matchRequestUrl } from '../utils/matching/matchRequestUrl.mjs';
import {
parseGraphQLRequest,
parseDocumentNode
} from '../utils/internal/parseGraphQLRequest.mjs';
import { toPublicUrl } from '../utils/request/toPublicUrl.mjs';
import { devUtils } from '../utils/internal/devUtils.mjs';
import { getAllRequestCookies } from '../utils/request/getRequestCookies.mjs';
import { kDefaultContentType } from '../HttpResponse.mjs';
import { getAllAcceptedMimeTypes } from '../utils/request/getAllAcceptedMimeTypes.mjs';
function isDocumentNode(value) {
if (value == null) {
return false;
}
return typeof value === "object" && "kind" in value && "definitions" in value;
}
function isDocumentTypeDecoration(value) {
return value instanceof String;
}
class GraphQLHandler extends RequestHandler {
endpoint;
static parsedRequestCache = /* @__PURE__ */ new WeakMap();
static #parseOperationName(predicate, operationType) {
const getOperationName = (node) => {
invariant(
node.operationType === operationType,
'Failed to create a GraphQL handler: provided a DocumentNode with a mismatched operation type (expected "%s" but got "%s").',
operationType,
node.operationType
);
invariant(
node.operationName,
"Failed to create a GraphQL handler: provided a DocumentNode without operation name"
);
return node.operationName;
};
if (isDocumentNode(predicate)) {
return getOperationName(parseDocumentNode(predicate));
}
if (isDocumentTypeDecoration(predicate)) {
const documentNode = parse(predicate.toString());
invariant(
isDocumentNode(documentNode),
"Failed to create a GraphQL handler: given TypedDocumentString (%s) does not produce a valid DocumentNode",
predicate
);
return getOperationName(parseDocumentNode(documentNode));
}
return predicate;
}
constructor(operationType, predicate, endpoint, resolver, options) {
const operationName = GraphQLHandler.#parseOperationName(
predicate,
operationType
);
const displayOperationName = typeof operationName === "function" ? "[custom predicate]" : operationName;
const header = operationType === "all" ? `${operationType} (origin: ${endpoint.toString()})` : `${operationType}${displayOperationName ? ` ${displayOperationName}` : ""} (origin: ${endpoint.toString()})`;
super({
info: {
header,
operationType,
operationName: GraphQLHandler.#parseOperationName(
predicate,
operationType
)
},
resolver,
options
});
this.endpoint = endpoint;
}
/**
* Parses the request body, once per request, cached across all
* GraphQL handlers. This is done to avoid multiple parsing of the
* request body, which each requires a clone of the request.
*/
async parseGraphQLRequestOrGetFromCache(request) {
if (!GraphQLHandler.parsedRequestCache.has(request)) {
GraphQLHandler.parsedRequestCache.set(
request,
await parseGraphQLRequest(request).catch((error) => {
console.error(error);
return void 0;
})
);
}
return GraphQLHandler.parsedRequestCache.get(request);
}
async parse(args) {
const match = matchRequestUrl(new URL(args.request.url), this.endpoint);
const cookies = getAllRequestCookies(args.request);
if (!match.matches) {
return {
match,
cookies
};
}
const parsedResult = await this.parseGraphQLRequestOrGetFromCache(
args.request
);
if (typeof parsedResult === "undefined") {
return {
match,
cookies
};
}
return {
match,
cookies,
query: parsedResult.query,
operationType: parsedResult.operationType,
operationName: parsedResult.operationName,
variables: parsedResult.variables
};
}
async predicate(args) {
if (args.parsedResult.operationType === void 0) {
return false;
}
if (!args.parsedResult.operationName && this.info.operationType !== "all") {
const publicUrl = toPublicUrl(args.request.url);
devUtils.warn(`Failed to intercept a GraphQL request at "${args.request.method} ${publicUrl}": anonymous GraphQL operations are not supported.
Consider naming this operation or using "graphql.operation()" request handler to intercept GraphQL requests regardless of their operation name/type. Read more: https://mswjs.io/docs/api/graphql/#graphqloperationresolver`);
return false;
}
const hasMatchingOperationType = this.info.operationType === "all" || args.parsedResult.operationType === this.info.operationType;
const hasMatchingOperationName = await this.matchOperationName({
request: args.request,
parsedResult: args.parsedResult
});
return args.parsedResult.match.matches && hasMatchingOperationType && hasMatchingOperationName;
}
async run(args) {
const result = await super.run(args);
if (result?.response == null) {
return result;
}
if (!(kDefaultContentType in result.response)) {
return result;
}
const acceptedMimeTypes = getAllAcceptedMimeTypes(
args.request.headers.get("accept")
);
if (acceptedMimeTypes.length === 0) {
return result;
}
const graphqlResponseIndex = acceptedMimeTypes.indexOf(
"application/graphql-response+json"
);
const jsonIndex = acceptedMimeTypes.indexOf("application/json");
if (graphqlResponseIndex !== -1 && (jsonIndex === -1 || graphqlResponseIndex <= jsonIndex)) {
result.response.headers.set(
"content-type",
"application/graphql-response+json"
);
}
return result;
}
async matchOperationName(args) {
if (typeof this.info.operationName === "function") {
const customPredicateResult = await this.info.operationName({
request: args.request,
...this.extendResolverArgs({
request: args.request,
parsedResult: args.parsedResult
})
});
return typeof customPredicateResult === "boolean" ? customPredicateResult : customPredicateResult.matches;
}
if (this.info.operationName instanceof RegExp) {
return this.info.operationName.test(args.parsedResult.operationName || "");
}
return args.parsedResult.operationName === this.info.operationName;
}
extendResolverArgs(args) {
return {
query: args.parsedResult.query || "",
operationType: args.parsedResult.operationType,
operationName: args.parsedResult.operationName || "",
variables: args.parsedResult.variables || {},
cookies: args.parsedResult.cookies
};
}
async log(args) {
const loggedRequest = await serializeRequest(args.request);
const loggedResponse = await serializeResponse(args.response);
const statusColor = getStatusCodeColor(loggedResponse.status);
const requestInfo = args.parsedResult.operationName ? `${args.parsedResult.operationType} ${args.parsedResult.operationName}` : `anonymous ${args.parsedResult.operationType}`;
console.groupCollapsed(
devUtils.formatMessage(
`${getTimestamp()} ${requestInfo} (%c${loggedResponse.status} ${loggedResponse.statusText}%c)`
),
`color:${statusColor}`,
"color:inherit"
);
console.log("Request:", loggedRequest);
console.log("Handler:", this);
console.log("Response:", loggedResponse);
console.groupEnd();
}
}
export {
GraphQLHandler,
isDocumentNode
};
//# sourceMappingURL=GraphQLHandler.mjs.map

File diff suppressed because one or more lines are too long

75
node_modules/msw/lib/core/handlers/HttpHandler.d.mts generated vendored Normal file
View File

@@ -0,0 +1,75 @@
import { R as RequestHandler, r as RequestHandlerDefaultInfo, a as ResponseResolver, c as RequestHandlerOptions, m as ResponseResolutionContext } from '../HttpResponse-Be4eT3x6.mjs';
import { PathParams, Path, Match } from '../utils/matching/matchRequestUrl.mjs';
import '@mswjs/interceptors';
import '../utils/internal/isIterable.mjs';
import '../typeUtils.mjs';
import 'graphql';
type HttpHandlerMethod = string | RegExp;
interface HttpHandlerInfo extends RequestHandlerDefaultInfo {
method: HttpHandlerMethod;
path: HttpRequestPredicate<PathParams>;
}
declare enum HttpMethods {
HEAD = "HEAD",
GET = "GET",
POST = "POST",
PUT = "PUT",
PATCH = "PATCH",
OPTIONS = "OPTIONS",
DELETE = "DELETE"
}
type RequestQuery = {
[queryName: string]: string;
};
type HttpRequestParsedResult = {
match: Match;
cookies: Record<string, string>;
};
type HttpRequestResolverExtras<Params extends PathParams> = {
params: Params;
cookies: Record<string, string>;
};
type HttpCustomPredicate<Params extends PathParams> = (args: {
request: Request;
cookies: Record<string, string>;
}) => HttpCustomPredicateResult<Params> | Promise<HttpCustomPredicateResult<Params>>;
type HttpCustomPredicateResult<Params extends PathParams> = boolean | {
matches: boolean;
params: Params;
};
type HttpRequestPredicate<Params extends PathParams> = Path | HttpCustomPredicate<Params>;
/**
* Request handler for HTTP requests.
* Provides request matching based on method and URL.
*/
declare class HttpHandler extends RequestHandler<HttpHandlerInfo, HttpRequestParsedResult, HttpRequestResolverExtras<any>> {
constructor(method: HttpHandlerMethod, predicate: HttpRequestPredicate<PathParams>, resolver: ResponseResolver<HttpRequestResolverExtras<any>, any, any>, options?: RequestHandlerOptions);
private checkRedundantQueryParameters;
parse(args: {
request: Request;
resolutionContext?: ResponseResolutionContext;
}): Promise<{
match: Match;
cookies: Record<string, string>;
}>;
predicate(args: {
request: Request;
parsedResult: HttpRequestParsedResult;
resolutionContext?: ResponseResolutionContext;
}): Promise<boolean>;
private matchMethod;
protected extendResolverArgs(args: {
request: Request;
parsedResult: HttpRequestParsedResult;
}): {
params: PathParams<string>;
cookies: Record<string, string>;
};
log(args: {
request: Request;
response: Response;
}): Promise<void>;
}
export { type HttpCustomPredicate, type HttpCustomPredicateResult, HttpHandler, type HttpHandlerInfo, type HttpHandlerMethod, HttpMethods, type HttpRequestParsedResult, type HttpRequestPredicate, type HttpRequestResolverExtras, type RequestQuery };

75
node_modules/msw/lib/core/handlers/HttpHandler.d.ts generated vendored Normal file
View File

@@ -0,0 +1,75 @@
import { R as RequestHandler, r as RequestHandlerDefaultInfo, a as ResponseResolver, c as RequestHandlerOptions, m as ResponseResolutionContext } from '../HttpResponse-Dj6ibgFJ.js';
import { PathParams, Path, Match } from '../utils/matching/matchRequestUrl.js';
import '@mswjs/interceptors';
import '../utils/internal/isIterable.js';
import '../typeUtils.js';
import 'graphql';
type HttpHandlerMethod = string | RegExp;
interface HttpHandlerInfo extends RequestHandlerDefaultInfo {
method: HttpHandlerMethod;
path: HttpRequestPredicate<PathParams>;
}
declare enum HttpMethods {
HEAD = "HEAD",
GET = "GET",
POST = "POST",
PUT = "PUT",
PATCH = "PATCH",
OPTIONS = "OPTIONS",
DELETE = "DELETE"
}
type RequestQuery = {
[queryName: string]: string;
};
type HttpRequestParsedResult = {
match: Match;
cookies: Record<string, string>;
};
type HttpRequestResolverExtras<Params extends PathParams> = {
params: Params;
cookies: Record<string, string>;
};
type HttpCustomPredicate<Params extends PathParams> = (args: {
request: Request;
cookies: Record<string, string>;
}) => HttpCustomPredicateResult<Params> | Promise<HttpCustomPredicateResult<Params>>;
type HttpCustomPredicateResult<Params extends PathParams> = boolean | {
matches: boolean;
params: Params;
};
type HttpRequestPredicate<Params extends PathParams> = Path | HttpCustomPredicate<Params>;
/**
* Request handler for HTTP requests.
* Provides request matching based on method and URL.
*/
declare class HttpHandler extends RequestHandler<HttpHandlerInfo, HttpRequestParsedResult, HttpRequestResolverExtras<any>> {
constructor(method: HttpHandlerMethod, predicate: HttpRequestPredicate<PathParams>, resolver: ResponseResolver<HttpRequestResolverExtras<any>, any, any>, options?: RequestHandlerOptions);
private checkRedundantQueryParameters;
parse(args: {
request: Request;
resolutionContext?: ResponseResolutionContext;
}): Promise<{
match: Match;
cookies: Record<string, string>;
}>;
predicate(args: {
request: Request;
parsedResult: HttpRequestParsedResult;
resolutionContext?: ResponseResolutionContext;
}): Promise<boolean>;
private matchMethod;
protected extendResolverArgs(args: {
request: Request;
parsedResult: HttpRequestParsedResult;
}): {
params: PathParams<string>;
cookies: Record<string, string>;
};
log(args: {
request: Request;
response: Response;
}): Promise<void>;
}
export { type HttpCustomPredicate, type HttpCustomPredicateResult, HttpHandler, type HttpHandlerInfo, type HttpHandlerMethod, HttpMethods, type HttpRequestParsedResult, type HttpRequestPredicate, type HttpRequestResolverExtras, type RequestQuery };

128
node_modules/msw/lib/core/handlers/HttpHandler.js generated vendored Normal file
View File

@@ -0,0 +1,128 @@
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var HttpHandler_exports = {};
__export(HttpHandler_exports, {
HttpHandler: () => HttpHandler,
HttpMethods: () => HttpMethods
});
module.exports = __toCommonJS(HttpHandler_exports);
var import_devUtils = require("../utils/internal/devUtils");
var import_isStringEqual = require("../utils/internal/isStringEqual");
var import_getStatusCodeColor = require("../utils/logging/getStatusCodeColor");
var import_getTimestamp = require("../utils/logging/getTimestamp");
var import_serializeRequest = require("../utils/logging/serializeRequest");
var import_serializeResponse = require("../utils/logging/serializeResponse");
var import_matchRequestUrl = require("../utils/matching/matchRequestUrl");
var import_toPublicUrl = require("../utils/request/toPublicUrl");
var import_getRequestCookies = require("../utils/request/getRequestCookies");
var import_cleanUrl = require("../utils/url/cleanUrl");
var import_RequestHandler = require("./RequestHandler");
var HttpMethods = /* @__PURE__ */ ((HttpMethods2) => {
HttpMethods2["HEAD"] = "HEAD";
HttpMethods2["GET"] = "GET";
HttpMethods2["POST"] = "POST";
HttpMethods2["PUT"] = "PUT";
HttpMethods2["PATCH"] = "PATCH";
HttpMethods2["OPTIONS"] = "OPTIONS";
HttpMethods2["DELETE"] = "DELETE";
return HttpMethods2;
})(HttpMethods || {});
class HttpHandler extends import_RequestHandler.RequestHandler {
constructor(method, predicate, resolver, options) {
const displayPath = typeof predicate === "function" ? "[custom predicate]" : predicate;
super({
info: {
header: `${method}${displayPath ? ` ${displayPath}` : ""}`,
path: predicate,
method
},
resolver,
options
});
this.checkRedundantQueryParameters();
}
checkRedundantQueryParameters() {
const { method, path } = this.info;
if (!path || path instanceof RegExp || typeof path === "function") {
return;
}
const url = (0, import_cleanUrl.cleanUrl)(path);
if (url === path) {
return;
}
import_devUtils.devUtils.warn(
`Found a redundant usage of query parameters in the request handler URL for "${method} ${path}". Please match against a path instead and access query parameters using "new URL(request.url).searchParams" instead. Learn more: https://mswjs.io/docs/http/intercepting-requests#querysearch-parameters`
);
}
async parse(args) {
const url = new URL(args.request.url);
const cookies = (0, import_getRequestCookies.getAllRequestCookies)(args.request);
if (typeof this.info.path === "function") {
const customPredicateResult = await this.info.path({
request: args.request,
cookies
});
const match2 = typeof customPredicateResult === "boolean" ? {
matches: customPredicateResult,
params: {}
} : customPredicateResult;
return {
match: match2,
cookies
};
}
const match = this.info.path ? (0, import_matchRequestUrl.matchRequestUrl)(url, this.info.path, args.resolutionContext?.baseUrl) : { matches: false, params: {} };
return {
match,
cookies
};
}
async predicate(args) {
const hasMatchingMethod = this.matchMethod(args.request.method);
const hasMatchingUrl = args.parsedResult.match.matches;
return hasMatchingMethod && hasMatchingUrl;
}
matchMethod(actualMethod) {
return this.info.method instanceof RegExp ? this.info.method.test(actualMethod) : (0, import_isStringEqual.isStringEqual)(this.info.method, actualMethod);
}
extendResolverArgs(args) {
return {
params: args.parsedResult.match?.params || {},
cookies: args.parsedResult.cookies
};
}
async log(args) {
const publicUrl = (0, import_toPublicUrl.toPublicUrl)(args.request.url);
const loggedRequest = await (0, import_serializeRequest.serializeRequest)(args.request);
const loggedResponse = await (0, import_serializeResponse.serializeResponse)(args.response);
const statusColor = (0, import_getStatusCodeColor.getStatusCodeColor)(loggedResponse.status);
console.groupCollapsed(
import_devUtils.devUtils.formatMessage(
`${(0, import_getTimestamp.getTimestamp)()} ${args.request.method} ${publicUrl} (%c${loggedResponse.status} ${loggedResponse.statusText}%c)`
),
`color:${statusColor}`,
"color:inherit"
);
console.log("Request", loggedRequest);
console.log("Handler:", this);
console.log("Response", loggedResponse);
console.groupEnd();
}
}
//# sourceMappingURL=HttpHandler.js.map

File diff suppressed because one or more lines are too long

112
node_modules/msw/lib/core/handlers/HttpHandler.mjs generated vendored Normal file
View File

@@ -0,0 +1,112 @@
import { devUtils } from '../utils/internal/devUtils.mjs';
import { isStringEqual } from '../utils/internal/isStringEqual.mjs';
import { getStatusCodeColor } from '../utils/logging/getStatusCodeColor.mjs';
import { getTimestamp } from '../utils/logging/getTimestamp.mjs';
import { serializeRequest } from '../utils/logging/serializeRequest.mjs';
import { serializeResponse } from '../utils/logging/serializeResponse.mjs';
import {
matchRequestUrl
} from '../utils/matching/matchRequestUrl.mjs';
import { toPublicUrl } from '../utils/request/toPublicUrl.mjs';
import { getAllRequestCookies } from '../utils/request/getRequestCookies.mjs';
import { cleanUrl } from '../utils/url/cleanUrl.mjs';
import {
RequestHandler
} from './RequestHandler.mjs';
var HttpMethods = /* @__PURE__ */ ((HttpMethods2) => {
HttpMethods2["HEAD"] = "HEAD";
HttpMethods2["GET"] = "GET";
HttpMethods2["POST"] = "POST";
HttpMethods2["PUT"] = "PUT";
HttpMethods2["PATCH"] = "PATCH";
HttpMethods2["OPTIONS"] = "OPTIONS";
HttpMethods2["DELETE"] = "DELETE";
return HttpMethods2;
})(HttpMethods || {});
class HttpHandler extends RequestHandler {
constructor(method, predicate, resolver, options) {
const displayPath = typeof predicate === "function" ? "[custom predicate]" : predicate;
super({
info: {
header: `${method}${displayPath ? ` ${displayPath}` : ""}`,
path: predicate,
method
},
resolver,
options
});
this.checkRedundantQueryParameters();
}
checkRedundantQueryParameters() {
const { method, path } = this.info;
if (!path || path instanceof RegExp || typeof path === "function") {
return;
}
const url = cleanUrl(path);
if (url === path) {
return;
}
devUtils.warn(
`Found a redundant usage of query parameters in the request handler URL for "${method} ${path}". Please match against a path instead and access query parameters using "new URL(request.url).searchParams" instead. Learn more: https://mswjs.io/docs/http/intercepting-requests#querysearch-parameters`
);
}
async parse(args) {
const url = new URL(args.request.url);
const cookies = getAllRequestCookies(args.request);
if (typeof this.info.path === "function") {
const customPredicateResult = await this.info.path({
request: args.request,
cookies
});
const match2 = typeof customPredicateResult === "boolean" ? {
matches: customPredicateResult,
params: {}
} : customPredicateResult;
return {
match: match2,
cookies
};
}
const match = this.info.path ? matchRequestUrl(url, this.info.path, args.resolutionContext?.baseUrl) : { matches: false, params: {} };
return {
match,
cookies
};
}
async predicate(args) {
const hasMatchingMethod = this.matchMethod(args.request.method);
const hasMatchingUrl = args.parsedResult.match.matches;
return hasMatchingMethod && hasMatchingUrl;
}
matchMethod(actualMethod) {
return this.info.method instanceof RegExp ? this.info.method.test(actualMethod) : isStringEqual(this.info.method, actualMethod);
}
extendResolverArgs(args) {
return {
params: args.parsedResult.match?.params || {},
cookies: args.parsedResult.cookies
};
}
async log(args) {
const publicUrl = toPublicUrl(args.request.url);
const loggedRequest = await serializeRequest(args.request);
const loggedResponse = await serializeResponse(args.response);
const statusColor = getStatusCodeColor(loggedResponse.status);
console.groupCollapsed(
devUtils.formatMessage(
`${getTimestamp()} ${args.request.method} ${publicUrl} (%c${loggedResponse.status} ${loggedResponse.statusText}%c)`
),
`color:${statusColor}`,
"color:inherit"
);
console.log("Request", loggedRequest);
console.log("Handler:", this);
console.log("Response", loggedResponse);
console.groupEnd();
}
}
export {
HttpHandler,
HttpMethods
};
//# sourceMappingURL=HttpHandler.mjs.map

File diff suppressed because one or more lines are too long

View File

@@ -0,0 +1,6 @@
import '../utils/internal/isIterable.mjs';
export { A as AsyncResponseResolverReturnType, D as DefaultBodyType, d as DefaultRequestMultipartBody, J as JsonBodyType, M as MaybeAsyncResponseResolverReturnType, R as RequestHandler, L as RequestHandlerArgs, r as RequestHandlerDefaultInfo, N as RequestHandlerExecutionResult, K as RequestHandlerInternalInfo, c as RequestHandlerOptions, a as ResponseResolver, e as ResponseResolverInfo, b as ResponseResolverReturnType } from '../HttpResponse-Be4eT3x6.mjs';
import '../typeUtils.mjs';
import '@mswjs/interceptors';
import 'graphql';
import '../utils/matching/matchRequestUrl.mjs';

View File

@@ -0,0 +1,6 @@
import '../utils/internal/isIterable.js';
export { A as AsyncResponseResolverReturnType, D as DefaultBodyType, d as DefaultRequestMultipartBody, J as JsonBodyType, M as MaybeAsyncResponseResolverReturnType, R as RequestHandler, L as RequestHandlerArgs, r as RequestHandlerDefaultInfo, N as RequestHandlerExecutionResult, K as RequestHandlerInternalInfo, c as RequestHandlerOptions, a as ResponseResolver, e as ResponseResolverInfo, b as ResponseResolverReturnType } from '../HttpResponse-Dj6ibgFJ.js';
import '../typeUtils.js';
import '@mswjs/interceptors';
import 'graphql';
import '../utils/matching/matchRequestUrl.js';

173
node_modules/msw/lib/core/handlers/RequestHandler.js generated vendored Normal file
View File

@@ -0,0 +1,173 @@
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var RequestHandler_exports = {};
__export(RequestHandler_exports, {
RequestHandler: () => RequestHandler
});
module.exports = __toCommonJS(RequestHandler_exports);
var import_getCallFrame = require("../utils/internal/getCallFrame");
var import_isIterable = require("../utils/internal/isIterable");
class RequestHandler {
static cache = /* @__PURE__ */ new WeakMap();
__kind;
info;
/**
* Indicates whether this request handler has been used
* (its resolver has successfully executed).
*/
isUsed;
resolver;
resolverIterator;
resolverIteratorResult;
options;
constructor(args) {
this.resolver = args.resolver;
this.options = args.options;
const callFrame = (0, import_getCallFrame.getCallFrame)(new Error());
this.info = {
...args.info,
callFrame
};
this.isUsed = false;
this.__kind = "RequestHandler";
}
/**
* Parse the intercepted request to extract additional information from it.
* Parsed result is then exposed to other methods of this request handler.
*/
async parse(_args) {
return {};
}
/**
* Test if this handler matches the given request.
*
* This method is not used internally but is exposed
* as a convenience method for consumers writing custom
* handlers.
*/
async test(args) {
const parsedResult = await this.parse({
request: args.request,
resolutionContext: args.resolutionContext
});
return this.predicate({
request: args.request,
parsedResult,
resolutionContext: args.resolutionContext
});
}
extendResolverArgs(_args) {
return {};
}
// Clone the request instance before it's passed to the handler phases
// and the response resolver so we can always read it for logging.
// We only clone it once per request to avoid unnecessary overhead.
cloneRequestOrGetFromCache(request) {
const existingClone = RequestHandler.cache.get(request);
if (typeof existingClone !== "undefined") {
return existingClone;
}
const clonedRequest = request.clone();
RequestHandler.cache.set(request, clonedRequest);
return clonedRequest;
}
/**
* Execute this request handler and produce a mocked response
* using the given resolver function.
*/
async run(args) {
if (this.isUsed && this.options?.once) {
return null;
}
const requestClone = this.cloneRequestOrGetFromCache(args.request);
const parsedResult = await this.parse({
request: args.request,
resolutionContext: args.resolutionContext
});
const shouldInterceptRequest = await this.predicate({
request: args.request,
parsedResult,
resolutionContext: args.resolutionContext
});
if (!shouldInterceptRequest) {
return null;
}
if (this.isUsed && this.options?.once) {
return null;
}
this.isUsed = true;
const executeResolver = this.wrapResolver(this.resolver);
const resolverExtras = this.extendResolverArgs({
request: args.request,
parsedResult
});
const mockedResponsePromise = executeResolver({
...resolverExtras,
requestId: args.requestId,
request: args.request
}).catch((errorOrResponse) => {
if (errorOrResponse instanceof Response) {
return errorOrResponse;
}
throw errorOrResponse;
});
const mockedResponse = await mockedResponsePromise;
const executionResult = this.createExecutionResult({
// Pass the cloned request to the result so that logging
// and other consumers could read its body once more.
request: requestClone,
requestId: args.requestId,
response: mockedResponse,
parsedResult
});
return executionResult;
}
wrapResolver(resolver) {
return async (info) => {
if (!this.resolverIterator) {
const result = await resolver(info);
if (!(0, import_isIterable.isIterable)(result)) {
return result;
}
this.resolverIterator = Symbol.iterator in result ? result[Symbol.iterator]() : result[Symbol.asyncIterator]();
}
this.isUsed = false;
const { done, value } = await this.resolverIterator.next();
const nextResponse = await value;
if (nextResponse) {
this.resolverIteratorResult = nextResponse.clone();
}
if (done) {
this.isUsed = true;
return this.resolverIteratorResult?.clone();
}
return nextResponse;
};
}
createExecutionResult(args) {
return {
handler: this,
request: args.request,
requestId: args.requestId,
response: args.response,
parsedResult: args.parsedResult
};
}
}
//# sourceMappingURL=RequestHandler.js.map

File diff suppressed because one or more lines are too long

155
node_modules/msw/lib/core/handlers/RequestHandler.mjs generated vendored Normal file
View File

@@ -0,0 +1,155 @@
import { getCallFrame } from '../utils/internal/getCallFrame.mjs';
import {
isIterable
} from '../utils/internal/isIterable.mjs';
class RequestHandler {
static cache = /* @__PURE__ */ new WeakMap();
__kind;
info;
/**
* Indicates whether this request handler has been used
* (its resolver has successfully executed).
*/
isUsed;
resolver;
resolverIterator;
resolverIteratorResult;
options;
constructor(args) {
this.resolver = args.resolver;
this.options = args.options;
const callFrame = getCallFrame(new Error());
this.info = {
...args.info,
callFrame
};
this.isUsed = false;
this.__kind = "RequestHandler";
}
/**
* Parse the intercepted request to extract additional information from it.
* Parsed result is then exposed to other methods of this request handler.
*/
async parse(_args) {
return {};
}
/**
* Test if this handler matches the given request.
*
* This method is not used internally but is exposed
* as a convenience method for consumers writing custom
* handlers.
*/
async test(args) {
const parsedResult = await this.parse({
request: args.request,
resolutionContext: args.resolutionContext
});
return this.predicate({
request: args.request,
parsedResult,
resolutionContext: args.resolutionContext
});
}
extendResolverArgs(_args) {
return {};
}
// Clone the request instance before it's passed to the handler phases
// and the response resolver so we can always read it for logging.
// We only clone it once per request to avoid unnecessary overhead.
cloneRequestOrGetFromCache(request) {
const existingClone = RequestHandler.cache.get(request);
if (typeof existingClone !== "undefined") {
return existingClone;
}
const clonedRequest = request.clone();
RequestHandler.cache.set(request, clonedRequest);
return clonedRequest;
}
/**
* Execute this request handler and produce a mocked response
* using the given resolver function.
*/
async run(args) {
if (this.isUsed && this.options?.once) {
return null;
}
const requestClone = this.cloneRequestOrGetFromCache(args.request);
const parsedResult = await this.parse({
request: args.request,
resolutionContext: args.resolutionContext
});
const shouldInterceptRequest = await this.predicate({
request: args.request,
parsedResult,
resolutionContext: args.resolutionContext
});
if (!shouldInterceptRequest) {
return null;
}
if (this.isUsed && this.options?.once) {
return null;
}
this.isUsed = true;
const executeResolver = this.wrapResolver(this.resolver);
const resolverExtras = this.extendResolverArgs({
request: args.request,
parsedResult
});
const mockedResponsePromise = executeResolver({
...resolverExtras,
requestId: args.requestId,
request: args.request
}).catch((errorOrResponse) => {
if (errorOrResponse instanceof Response) {
return errorOrResponse;
}
throw errorOrResponse;
});
const mockedResponse = await mockedResponsePromise;
const executionResult = this.createExecutionResult({
// Pass the cloned request to the result so that logging
// and other consumers could read its body once more.
request: requestClone,
requestId: args.requestId,
response: mockedResponse,
parsedResult
});
return executionResult;
}
wrapResolver(resolver) {
return async (info) => {
if (!this.resolverIterator) {
const result = await resolver(info);
if (!isIterable(result)) {
return result;
}
this.resolverIterator = Symbol.iterator in result ? result[Symbol.iterator]() : result[Symbol.asyncIterator]();
}
this.isUsed = false;
const { done, value } = await this.resolverIterator.next();
const nextResponse = await value;
if (nextResponse) {
this.resolverIteratorResult = nextResponse.clone();
}
if (done) {
this.isUsed = true;
return this.resolverIteratorResult?.clone();
}
return nextResponse;
};
}
createExecutionResult(args) {
return {
handler: this,
request: args.request,
requestId: args.requestId,
response: args.response,
parsedResult: args.parsedResult
};
}
}
export {
RequestHandler
};
//# sourceMappingURL=RequestHandler.mjs.map

File diff suppressed because one or more lines are too long

View File

@@ -0,0 +1,42 @@
import { Emitter } from 'strict-event-emitter';
import { WebSocketClientConnectionProtocol, WebSocketServerConnectionProtocol, WebSocketConnectionData } from '@mswjs/interceptors/WebSocket';
import { Path, PathParams, Match } from '../utils/matching/matchRequestUrl.mjs';
type WebSocketHandlerParsedResult = {
match: Match;
};
type WebSocketHandlerEventMap = {
connection: [args: WebSocketHandlerConnection];
};
interface WebSocketHandlerConnection {
client: WebSocketClientConnectionProtocol;
server: WebSocketServerConnectionProtocol;
info: WebSocketConnectionData['info'];
params: PathParams;
}
interface WebSocketResolutionContext {
baseUrl?: string;
}
declare const kEmitter: unique symbol;
declare const kSender: unique symbol;
declare class WebSocketHandler {
#private;
protected readonly url: Path;
private readonly __kind;
id: string;
callFrame?: string;
protected [kEmitter]: Emitter<WebSocketHandlerEventMap>;
constructor(url: Path);
parse(args: {
url: URL;
resolutionContext?: WebSocketResolutionContext;
}): WebSocketHandlerParsedResult;
predicate(args: {
url: URL;
parsedResult: WebSocketHandlerParsedResult;
}): boolean;
run(connection: Omit<WebSocketHandlerConnection, 'params'>, resolutionContext?: WebSocketResolutionContext): Promise<boolean>;
protected connect(connection: WebSocketHandlerConnection): boolean;
}
export { WebSocketHandler, type WebSocketHandlerConnection, type WebSocketHandlerEventMap, type WebSocketResolutionContext, kEmitter, kSender };

View File

@@ -0,0 +1,42 @@
import { Emitter } from 'strict-event-emitter';
import { WebSocketClientConnectionProtocol, WebSocketServerConnectionProtocol, WebSocketConnectionData } from '@mswjs/interceptors/WebSocket';
import { Path, PathParams, Match } from '../utils/matching/matchRequestUrl.js';
type WebSocketHandlerParsedResult = {
match: Match;
};
type WebSocketHandlerEventMap = {
connection: [args: WebSocketHandlerConnection];
};
interface WebSocketHandlerConnection {
client: WebSocketClientConnectionProtocol;
server: WebSocketServerConnectionProtocol;
info: WebSocketConnectionData['info'];
params: PathParams;
}
interface WebSocketResolutionContext {
baseUrl?: string;
}
declare const kEmitter: unique symbol;
declare const kSender: unique symbol;
declare class WebSocketHandler {
#private;
protected readonly url: Path;
private readonly __kind;
id: string;
callFrame?: string;
protected [kEmitter]: Emitter<WebSocketHandlerEventMap>;
constructor(url: Path);
parse(args: {
url: URL;
resolutionContext?: WebSocketResolutionContext;
}): WebSocketHandlerParsedResult;
predicate(args: {
url: URL;
parsedResult: WebSocketHandlerParsedResult;
}): boolean;
run(connection: Omit<WebSocketHandlerConnection, 'params'>, resolutionContext?: WebSocketResolutionContext): Promise<boolean>;
protected connect(connection: WebSocketHandlerConnection): boolean;
}
export { WebSocketHandler, type WebSocketHandlerConnection, type WebSocketHandlerEventMap, type WebSocketResolutionContext, kEmitter, kSender };

147
node_modules/msw/lib/core/handlers/WebSocketHandler.js generated vendored Normal file
View File

@@ -0,0 +1,147 @@
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var WebSocketHandler_exports = {};
__export(WebSocketHandler_exports, {
WebSocketHandler: () => WebSocketHandler,
kEmitter: () => kEmitter,
kSender: () => kSender
});
module.exports = __toCommonJS(WebSocketHandler_exports);
var import_strict_event_emitter = require("strict-event-emitter");
var import_interceptors = require("@mswjs/interceptors");
var import_matchRequestUrl = require("../utils/matching/matchRequestUrl");
var import_getCallFrame = require("../utils/internal/getCallFrame");
const kEmitter = Symbol("kEmitter");
const kSender = Symbol("kSender");
const kStopPropagationPatched = Symbol("kStopPropagationPatched");
const KOnStopPropagation = Symbol("KOnStopPropagation");
class WebSocketHandler {
constructor(url) {
this.url = url;
this.id = (0, import_interceptors.createRequestId)();
this[kEmitter] = new import_strict_event_emitter.Emitter();
this.callFrame = (0, import_getCallFrame.getCallFrame)(new Error());
this.__kind = "EventHandler";
}
__kind;
id;
callFrame;
[kEmitter];
parse(args) {
const clientUrl = new URL(args.url);
const resolvedHandlerUrl = this.url instanceof RegExp || this.url.startsWith("*") ? this.url : this.#resolveWebSocketUrl(this.url, args.resolutionContext?.baseUrl);
clientUrl.pathname = clientUrl.pathname.replace(/^\/socket.io\//, "/");
const match = (0, import_matchRequestUrl.matchRequestUrl)(
clientUrl,
resolvedHandlerUrl,
args.resolutionContext?.baseUrl
);
return {
match
};
}
predicate(args) {
return args.parsedResult.match.matches;
}
async run(connection, resolutionContext) {
const parsedResult = this.parse({
url: connection.client.url,
resolutionContext
});
if (!this.predicate({ url: connection.client.url, parsedResult })) {
return false;
}
const resolvedConnection = {
...connection,
params: parsedResult.match.params || {}
};
return this.connect(resolvedConnection);
}
connect(connection) {
connection.client.addEventListener(
"message",
createStopPropagationListener(this)
);
connection.client.addEventListener(
"close",
createStopPropagationListener(this)
);
connection.server.addEventListener(
"open",
createStopPropagationListener(this)
);
connection.server.addEventListener(
"message",
createStopPropagationListener(this)
);
connection.server.addEventListener(
"error",
createStopPropagationListener(this)
);
connection.server.addEventListener(
"close",
createStopPropagationListener(this)
);
return this[kEmitter].emit("connection", connection);
}
#resolveWebSocketUrl(url, baseUrl) {
const resolvedUrl = (0, import_interceptors.resolveWebSocketUrl)(
baseUrl ? (
/**
* @note Resolve against the base URL preemtively because `resolveWebSocketUrl` only
* resolves against `location.href`, which is missing in Node.js. Base URL allows
* the handler to accept a relative URL in Node.js.
*/
new URL(url, baseUrl)
) : url
);
return resolvedUrl.replace(/\/$/, "");
}
}
function createStopPropagationListener(handler) {
return function stopPropagationListener(event) {
const propagationStoppedAt = Reflect.get(event, "kPropagationStoppedAt");
if (propagationStoppedAt && handler.id !== propagationStoppedAt) {
event.stopImmediatePropagation();
return;
}
Object.defineProperty(event, KOnStopPropagation, {
value() {
Object.defineProperty(event, "kPropagationStoppedAt", {
value: handler.id
});
},
configurable: true
});
if (!Reflect.get(event, kStopPropagationPatched)) {
event.stopPropagation = new Proxy(event.stopPropagation, {
apply: (target, thisArg, args) => {
Reflect.get(event, KOnStopPropagation)?.call(handler);
return Reflect.apply(target, thisArg, args);
}
});
Object.defineProperty(event, kStopPropagationPatched, {
value: true,
// If something else attempts to redefine this, throw.
configurable: false
});
}
};
}
//# sourceMappingURL=WebSocketHandler.js.map

File diff suppressed because one or more lines are too long

129
node_modules/msw/lib/core/handlers/WebSocketHandler.mjs generated vendored Normal file
View File

@@ -0,0 +1,129 @@
import { Emitter } from "strict-event-emitter";
import { createRequestId, resolveWebSocketUrl } from "@mswjs/interceptors";
import {
matchRequestUrl
} from '../utils/matching/matchRequestUrl.mjs';
import { getCallFrame } from '../utils/internal/getCallFrame.mjs';
const kEmitter = Symbol("kEmitter");
const kSender = Symbol("kSender");
const kStopPropagationPatched = Symbol("kStopPropagationPatched");
const KOnStopPropagation = Symbol("KOnStopPropagation");
class WebSocketHandler {
constructor(url) {
this.url = url;
this.id = createRequestId();
this[kEmitter] = new Emitter();
this.callFrame = getCallFrame(new Error());
this.__kind = "EventHandler";
}
__kind;
id;
callFrame;
[kEmitter];
parse(args) {
const clientUrl = new URL(args.url);
const resolvedHandlerUrl = this.url instanceof RegExp || this.url.startsWith("*") ? this.url : this.#resolveWebSocketUrl(this.url, args.resolutionContext?.baseUrl);
clientUrl.pathname = clientUrl.pathname.replace(/^\/socket.io\//, "/");
const match = matchRequestUrl(
clientUrl,
resolvedHandlerUrl,
args.resolutionContext?.baseUrl
);
return {
match
};
}
predicate(args) {
return args.parsedResult.match.matches;
}
async run(connection, resolutionContext) {
const parsedResult = this.parse({
url: connection.client.url,
resolutionContext
});
if (!this.predicate({ url: connection.client.url, parsedResult })) {
return false;
}
const resolvedConnection = {
...connection,
params: parsedResult.match.params || {}
};
return this.connect(resolvedConnection);
}
connect(connection) {
connection.client.addEventListener(
"message",
createStopPropagationListener(this)
);
connection.client.addEventListener(
"close",
createStopPropagationListener(this)
);
connection.server.addEventListener(
"open",
createStopPropagationListener(this)
);
connection.server.addEventListener(
"message",
createStopPropagationListener(this)
);
connection.server.addEventListener(
"error",
createStopPropagationListener(this)
);
connection.server.addEventListener(
"close",
createStopPropagationListener(this)
);
return this[kEmitter].emit("connection", connection);
}
#resolveWebSocketUrl(url, baseUrl) {
const resolvedUrl = resolveWebSocketUrl(
baseUrl ? (
/**
* @note Resolve against the base URL preemtively because `resolveWebSocketUrl` only
* resolves against `location.href`, which is missing in Node.js. Base URL allows
* the handler to accept a relative URL in Node.js.
*/
new URL(url, baseUrl)
) : url
);
return resolvedUrl.replace(/\/$/, "");
}
}
function createStopPropagationListener(handler) {
return function stopPropagationListener(event) {
const propagationStoppedAt = Reflect.get(event, "kPropagationStoppedAt");
if (propagationStoppedAt && handler.id !== propagationStoppedAt) {
event.stopImmediatePropagation();
return;
}
Object.defineProperty(event, KOnStopPropagation, {
value() {
Object.defineProperty(event, "kPropagationStoppedAt", {
value: handler.id
});
},
configurable: true
});
if (!Reflect.get(event, kStopPropagationPatched)) {
event.stopPropagation = new Proxy(event.stopPropagation, {
apply: (target, thisArg, args) => {
Reflect.get(event, KOnStopPropagation)?.call(handler);
return Reflect.apply(target, thisArg, args);
}
});
Object.defineProperty(event, kStopPropagationPatched, {
value: true,
// If something else attempts to redefine this, throw.
configurable: false
});
}
};
}
export {
WebSocketHandler,
kEmitter,
kSender
};
//# sourceMappingURL=WebSocketHandler.mjs.map

File diff suppressed because one or more lines are too long

3
node_modules/msw/lib/core/handlers/common.d.mts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
type HandlerKind = 'RequestHandler' | 'EventHandler';
export type { HandlerKind };

3
node_modules/msw/lib/core/handlers/common.d.ts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
type HandlerKind = 'RequestHandler' | 'EventHandler';
export type { HandlerKind };

17
node_modules/msw/lib/core/handlers/common.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var common_exports = {};
module.exports = __toCommonJS(common_exports);
//# sourceMappingURL=common.js.map

1
node_modules/msw/lib/core/handlers/common.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../../src/core/handlers/common.ts"],"sourcesContent":["export type HandlerKind = 'RequestHandler' | 'EventHandler'\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

1
node_modules/msw/lib/core/handlers/common.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
//# sourceMappingURL=common.mjs.map

1
node_modules/msw/lib/core/handlers/common.mjs.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

31
node_modules/msw/lib/core/http.d.mts generated vendored Normal file
View File

@@ -0,0 +1,31 @@
import { D as DefaultBodyType, a as ResponseResolver, c as RequestHandlerOptions } from './HttpResponse-Be4eT3x6.mjs';
import { HttpRequestPredicate, HttpRequestResolverExtras, HttpHandler } from './handlers/HttpHandler.mjs';
import { PathParams } from './utils/matching/matchRequestUrl.mjs';
import '@mswjs/interceptors';
import './utils/internal/isIterable.mjs';
import './typeUtils.mjs';
import 'graphql';
type HttpRequestHandler = <Params extends PathParams<keyof Params> = PathParams, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = undefined>(predicate: HttpRequestPredicate<Params>, resolver: HttpResponseResolver<Params, RequestBodyType, ResponseBodyType>, options?: RequestHandlerOptions) => HttpHandler;
type HttpResponseResolver<Params extends PathParams<keyof Params> = PathParams, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = DefaultBodyType> = ResponseResolver<HttpRequestResolverExtras<Params>, RequestBodyType, ResponseBodyType>;
/**
* A namespace to intercept and mock HTTP requests.
*
* @example
* http.get('/user', resolver)
* http.post('/post/:id', resolver)
*
* @see {@link https://mswjs.io/docs/api/http `http` API reference}
*/
declare const http: {
all: HttpRequestHandler;
head: HttpRequestHandler;
get: HttpRequestHandler;
post: HttpRequestHandler;
put: HttpRequestHandler;
delete: HttpRequestHandler;
patch: HttpRequestHandler;
options: HttpRequestHandler;
};
export { type HttpRequestHandler, type HttpResponseResolver, http };

31
node_modules/msw/lib/core/http.d.ts generated vendored Normal file
View File

@@ -0,0 +1,31 @@
import { D as DefaultBodyType, a as ResponseResolver, c as RequestHandlerOptions } from './HttpResponse-Dj6ibgFJ.js';
import { HttpRequestPredicate, HttpRequestResolverExtras, HttpHandler } from './handlers/HttpHandler.js';
import { PathParams } from './utils/matching/matchRequestUrl.js';
import '@mswjs/interceptors';
import './utils/internal/isIterable.js';
import './typeUtils.js';
import 'graphql';
type HttpRequestHandler = <Params extends PathParams<keyof Params> = PathParams, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = undefined>(predicate: HttpRequestPredicate<Params>, resolver: HttpResponseResolver<Params, RequestBodyType, ResponseBodyType>, options?: RequestHandlerOptions) => HttpHandler;
type HttpResponseResolver<Params extends PathParams<keyof Params> = PathParams, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = DefaultBodyType> = ResponseResolver<HttpRequestResolverExtras<Params>, RequestBodyType, ResponseBodyType>;
/**
* A namespace to intercept and mock HTTP requests.
*
* @example
* http.get('/user', resolver)
* http.post('/post/:id', resolver)
*
* @see {@link https://mswjs.io/docs/api/http `http` API reference}
*/
declare const http: {
all: HttpRequestHandler;
head: HttpRequestHandler;
get: HttpRequestHandler;
post: HttpRequestHandler;
put: HttpRequestHandler;
delete: HttpRequestHandler;
patch: HttpRequestHandler;
options: HttpRequestHandler;
};
export { type HttpRequestHandler, type HttpResponseResolver, http };

40
node_modules/msw/lib/core/http.js generated vendored Normal file
View File

@@ -0,0 +1,40 @@
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var http_exports = {};
__export(http_exports, {
http: () => http
});
module.exports = __toCommonJS(http_exports);
var import_HttpHandler = require("./handlers/HttpHandler");
function createHttpHandler(method) {
return (predicate, resolver, options = {}) => {
return new import_HttpHandler.HttpHandler(method, predicate, resolver, options);
};
}
const http = {
all: createHttpHandler(/.+/),
head: createHttpHandler(import_HttpHandler.HttpMethods.HEAD),
get: createHttpHandler(import_HttpHandler.HttpMethods.GET),
post: createHttpHandler(import_HttpHandler.HttpMethods.POST),
put: createHttpHandler(import_HttpHandler.HttpMethods.PUT),
delete: createHttpHandler(import_HttpHandler.HttpMethods.DELETE),
patch: createHttpHandler(import_HttpHandler.HttpMethods.PATCH),
options: createHttpHandler(import_HttpHandler.HttpMethods.OPTIONS)
};
//# sourceMappingURL=http.js.map

1
node_modules/msw/lib/core/http.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../src/core/http.ts"],"sourcesContent":["import {\n DefaultBodyType,\n RequestHandlerOptions,\n ResponseResolver,\n} from './handlers/RequestHandler'\nimport {\n HttpMethods,\n HttpHandler,\n HttpRequestResolverExtras,\n HttpRequestPredicate,\n} from './handlers/HttpHandler'\nimport type { PathParams } from './utils/matching/matchRequestUrl'\n\nexport type HttpRequestHandler = <\n Params extends PathParams<keyof Params> = PathParams,\n RequestBodyType extends DefaultBodyType = DefaultBodyType,\n // Response body type MUST be undefined by default.\n // This is how we can distinguish between a handler that\n // returns plain \"Response\" and the one returning \"HttpResponse\"\n // to enforce a stricter response body type.\n ResponseBodyType extends DefaultBodyType = undefined,\n>(\n predicate: HttpRequestPredicate<Params>,\n resolver: HttpResponseResolver<Params, RequestBodyType, ResponseBodyType>,\n options?: RequestHandlerOptions,\n) => HttpHandler\n\nexport type HttpResponseResolver<\n Params extends PathParams<keyof Params> = PathParams,\n RequestBodyType extends DefaultBodyType = DefaultBodyType,\n ResponseBodyType extends DefaultBodyType = DefaultBodyType,\n> = ResponseResolver<\n HttpRequestResolverExtras<Params>,\n RequestBodyType,\n ResponseBodyType\n>\n\nfunction createHttpHandler<Method extends HttpMethods | RegExp>(\n method: Method,\n): HttpRequestHandler {\n return (predicate, resolver, options = {}) => {\n return new HttpHandler(method, predicate, resolver, options)\n }\n}\n\n/**\n * A namespace to intercept and mock HTTP requests.\n *\n * @example\n * http.get('/user', resolver)\n * http.post('/post/:id', resolver)\n *\n * @see {@link https://mswjs.io/docs/api/http `http` API reference}\n */\nexport const http = {\n all: createHttpHandler(/.+/),\n head: createHttpHandler(HttpMethods.HEAD),\n get: createHttpHandler(HttpMethods.GET),\n post: createHttpHandler(HttpMethods.POST),\n put: createHttpHandler(HttpMethods.PUT),\n delete: createHttpHandler(HttpMethods.DELETE),\n patch: createHttpHandler(HttpMethods.PATCH),\n options: createHttpHandler(HttpMethods.OPTIONS),\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,yBAKO;AA2BP,SAAS,kBACP,QACoB;AACpB,SAAO,CAAC,WAAW,UAAU,UAAU,CAAC,MAAM;AAC5C,WAAO,IAAI,+BAAY,QAAQ,WAAW,UAAU,OAAO;AAAA,EAC7D;AACF;AAWO,MAAM,OAAO;AAAA,EAClB,KAAK,kBAAkB,IAAI;AAAA,EAC3B,MAAM,kBAAkB,+BAAY,IAAI;AAAA,EACxC,KAAK,kBAAkB,+BAAY,GAAG;AAAA,EACtC,MAAM,kBAAkB,+BAAY,IAAI;AAAA,EACxC,KAAK,kBAAkB,+BAAY,GAAG;AAAA,EACtC,QAAQ,kBAAkB,+BAAY,MAAM;AAAA,EAC5C,OAAO,kBAAkB,+BAAY,KAAK;AAAA,EAC1C,SAAS,kBAAkB,+BAAY,OAAO;AAChD;","names":[]}

23
node_modules/msw/lib/core/http.mjs generated vendored Normal file
View File

@@ -0,0 +1,23 @@
import {
HttpMethods,
HttpHandler
} from './handlers/HttpHandler.mjs';
function createHttpHandler(method) {
return (predicate, resolver, options = {}) => {
return new HttpHandler(method, predicate, resolver, options);
};
}
const http = {
all: createHttpHandler(/.+/),
head: createHttpHandler(HttpMethods.HEAD),
get: createHttpHandler(HttpMethods.GET),
post: createHttpHandler(HttpMethods.POST),
put: createHttpHandler(HttpMethods.PUT),
delete: createHttpHandler(HttpMethods.DELETE),
patch: createHttpHandler(HttpMethods.PATCH),
options: createHttpHandler(HttpMethods.OPTIONS)
};
export {
http
};
//# sourceMappingURL=http.mjs.map

1
node_modules/msw/lib/core/http.mjs.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../src/core/http.ts"],"sourcesContent":["import {\n DefaultBodyType,\n RequestHandlerOptions,\n ResponseResolver,\n} from './handlers/RequestHandler'\nimport {\n HttpMethods,\n HttpHandler,\n HttpRequestResolverExtras,\n HttpRequestPredicate,\n} from './handlers/HttpHandler'\nimport type { PathParams } from './utils/matching/matchRequestUrl'\n\nexport type HttpRequestHandler = <\n Params extends PathParams<keyof Params> = PathParams,\n RequestBodyType extends DefaultBodyType = DefaultBodyType,\n // Response body type MUST be undefined by default.\n // This is how we can distinguish between a handler that\n // returns plain \"Response\" and the one returning \"HttpResponse\"\n // to enforce a stricter response body type.\n ResponseBodyType extends DefaultBodyType = undefined,\n>(\n predicate: HttpRequestPredicate<Params>,\n resolver: HttpResponseResolver<Params, RequestBodyType, ResponseBodyType>,\n options?: RequestHandlerOptions,\n) => HttpHandler\n\nexport type HttpResponseResolver<\n Params extends PathParams<keyof Params> = PathParams,\n RequestBodyType extends DefaultBodyType = DefaultBodyType,\n ResponseBodyType extends DefaultBodyType = DefaultBodyType,\n> = ResponseResolver<\n HttpRequestResolverExtras<Params>,\n RequestBodyType,\n ResponseBodyType\n>\n\nfunction createHttpHandler<Method extends HttpMethods | RegExp>(\n method: Method,\n): HttpRequestHandler {\n return (predicate, resolver, options = {}) => {\n return new HttpHandler(method, predicate, resolver, options)\n }\n}\n\n/**\n * A namespace to intercept and mock HTTP requests.\n *\n * @example\n * http.get('/user', resolver)\n * http.post('/post/:id', resolver)\n *\n * @see {@link https://mswjs.io/docs/api/http `http` API reference}\n */\nexport const http = {\n all: createHttpHandler(/.+/),\n head: createHttpHandler(HttpMethods.HEAD),\n get: createHttpHandler(HttpMethods.GET),\n post: createHttpHandler(HttpMethods.POST),\n put: createHttpHandler(HttpMethods.PUT),\n delete: createHttpHandler(HttpMethods.DELETE),\n patch: createHttpHandler(HttpMethods.PATCH),\n options: createHttpHandler(HttpMethods.OPTIONS),\n}\n"],"mappings":"AAKA;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AA2BP,SAAS,kBACP,QACoB;AACpB,SAAO,CAAC,WAAW,UAAU,UAAU,CAAC,MAAM;AAC5C,WAAO,IAAI,YAAY,QAAQ,WAAW,UAAU,OAAO;AAAA,EAC7D;AACF;AAWO,MAAM,OAAO;AAAA,EAClB,KAAK,kBAAkB,IAAI;AAAA,EAC3B,MAAM,kBAAkB,YAAY,IAAI;AAAA,EACxC,KAAK,kBAAkB,YAAY,GAAG;AAAA,EACtC,MAAM,kBAAkB,YAAY,IAAI;AAAA,EACxC,KAAK,kBAAkB,YAAY,GAAG;AAAA,EACtC,QAAQ,kBAAkB,YAAY,MAAM;AAAA,EAC5C,OAAO,kBAAkB,YAAY,KAAK;AAAA,EAC1C,SAAS,kBAAkB,YAAY,OAAO;AAChD;","names":[]}

32
node_modules/msw/lib/core/index.d.mts generated vendored Normal file
View File

@@ -0,0 +1,32 @@
export { SetupApi } from './SetupApi.mjs';
import { G as GraphQLHandler } from './HttpResponse-Be4eT3x6.mjs';
export { A as AsyncResponseResolverReturnType, D as DefaultBodyType, d as DefaultRequestMultipartBody, l as GraphQLCustomPredicate, j as GraphQLJsonRequestBody, k as GraphQLOperationType, f as GraphQLQuery, h as GraphQLRequestBody, i as GraphQLResponseBody, g as GraphQLVariables, H as HttpResponse, n as HttpResponseInit, J as JsonBodyType, P as ParsedGraphQLRequest, R as RequestHandler, c as RequestHandlerOptions, m as ResponseResolutionContext, a as ResponseResolver, e as ResponseResolverInfo, b as ResponseResolverReturnType, S as StrictRequest, o as StrictResponse } from './HttpResponse-Be4eT3x6.mjs';
export { HttpRequestHandler, HttpResponseResolver, http } from './http.mjs';
import { HttpHandler } from './handlers/HttpHandler.mjs';
export { HttpCustomPredicate, HttpHandlerInfo, HttpHandlerMethod, HttpMethods, HttpRequestParsedResult, HttpRequestResolverExtras, RequestQuery } from './handlers/HttpHandler.mjs';
export { GraphQLLinkHandlers, GraphQLOperationHandler, GraphQLRequestHandler, GraphQLResponseResolver, graphql } from './graphql.mjs';
export { WebSocketEventListener, WebSocketLink, ws } from './ws.mjs';
import { WebSocketHandler } from './handlers/WebSocketHandler.mjs';
export { WebSocketHandlerConnection, WebSocketHandlerEventMap } from './handlers/WebSocketHandler.mjs';
export { ServerSentEventMessage, ServerSentEventRequestHandler, ServerSentEventResolver, ServerSentEventResolverExtras, sse } from './sse.mjs';
export { Match, Path, PathParams, matchRequestUrl } from './utils/matching/matchRequestUrl.mjs';
export { HandleRequestOptions, handleRequest } from './utils/handleRequest.mjs';
export { UnhandledRequestCallback, UnhandledRequestStrategy, onUnhandledRequest } from './utils/request/onUnhandledRequest.mjs';
export { getResponse } from './getResponse.mjs';
export { cleanUrl } from './utils/url/cleanUrl.mjs';
export { LifeCycleEventsMap, SharedOptions } from './sharedOptions.mjs';
export { DelayMode, delay } from './delay.mjs';
export { bypass } from './bypass.mjs';
export { passthrough } from './passthrough.mjs';
export { isCommonAssetRequest } from './isCommonAssetRequest.mjs';
export { WebSocketData } from '@mswjs/interceptors/WebSocket';
import 'strict-event-emitter';
import './utils/internal/Disposable.mjs';
import '@mswjs/interceptors';
import './utils/internal/isIterable.mjs';
import './typeUtils.mjs';
import 'graphql';
type AnyHandler = HttpHandler | GraphQLHandler | WebSocketHandler;
export { type AnyHandler, GraphQLHandler, HttpHandler, WebSocketHandler };

32
node_modules/msw/lib/core/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,32 @@
export { SetupApi } from './SetupApi.js';
import { G as GraphQLHandler } from './HttpResponse-Dj6ibgFJ.js';
export { A as AsyncResponseResolverReturnType, D as DefaultBodyType, d as DefaultRequestMultipartBody, l as GraphQLCustomPredicate, j as GraphQLJsonRequestBody, k as GraphQLOperationType, f as GraphQLQuery, h as GraphQLRequestBody, i as GraphQLResponseBody, g as GraphQLVariables, H as HttpResponse, n as HttpResponseInit, J as JsonBodyType, P as ParsedGraphQLRequest, R as RequestHandler, c as RequestHandlerOptions, m as ResponseResolutionContext, a as ResponseResolver, e as ResponseResolverInfo, b as ResponseResolverReturnType, S as StrictRequest, o as StrictResponse } from './HttpResponse-Dj6ibgFJ.js';
export { HttpRequestHandler, HttpResponseResolver, http } from './http.js';
import { HttpHandler } from './handlers/HttpHandler.js';
export { HttpCustomPredicate, HttpHandlerInfo, HttpHandlerMethod, HttpMethods, HttpRequestParsedResult, HttpRequestResolverExtras, RequestQuery } from './handlers/HttpHandler.js';
export { GraphQLLinkHandlers, GraphQLOperationHandler, GraphQLRequestHandler, GraphQLResponseResolver, graphql } from './graphql.js';
export { WebSocketEventListener, WebSocketLink, ws } from './ws.js';
import { WebSocketHandler } from './handlers/WebSocketHandler.js';
export { WebSocketHandlerConnection, WebSocketHandlerEventMap } from './handlers/WebSocketHandler.js';
export { ServerSentEventMessage, ServerSentEventRequestHandler, ServerSentEventResolver, ServerSentEventResolverExtras, sse } from './sse.js';
export { Match, Path, PathParams, matchRequestUrl } from './utils/matching/matchRequestUrl.js';
export { HandleRequestOptions, handleRequest } from './utils/handleRequest.js';
export { UnhandledRequestCallback, UnhandledRequestStrategy, onUnhandledRequest } from './utils/request/onUnhandledRequest.js';
export { getResponse } from './getResponse.js';
export { cleanUrl } from './utils/url/cleanUrl.js';
export { LifeCycleEventsMap, SharedOptions } from './sharedOptions.js';
export { DelayMode, delay } from './delay.js';
export { bypass } from './bypass.js';
export { passthrough } from './passthrough.js';
export { isCommonAssetRequest } from './isCommonAssetRequest.js';
export { WebSocketData } from '@mswjs/interceptors/WebSocket';
import 'strict-event-emitter';
import './utils/internal/Disposable.js';
import '@mswjs/interceptors';
import './utils/internal/isIterable.js';
import './typeUtils.js';
import 'graphql';
type AnyHandler = HttpHandler | GraphQLHandler | WebSocketHandler;
export { type AnyHandler, GraphQLHandler, HttpHandler, WebSocketHandler };

64
node_modules/msw/lib/core/index.js generated vendored Normal file
View File

@@ -0,0 +1,64 @@
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var index_exports = {};
__export(index_exports, {
GraphQLHandler: () => import_GraphQLHandler.GraphQLHandler,
HttpHandler: () => import_HttpHandler.HttpHandler,
HttpMethods: () => import_HttpHandler.HttpMethods,
HttpResponse: () => import_HttpResponse.HttpResponse,
RequestHandler: () => import_RequestHandler.RequestHandler,
SetupApi: () => import_SetupApi.SetupApi,
WebSocketHandler: () => import_WebSocketHandler.WebSocketHandler,
bypass: () => import_bypass.bypass,
cleanUrl: () => import_cleanUrl.cleanUrl,
delay: () => import_delay.delay,
getResponse: () => import_getResponse.getResponse,
graphql: () => import_graphql.graphql,
handleRequest: () => import_handleRequest.handleRequest,
http: () => import_http.http,
isCommonAssetRequest: () => import_isCommonAssetRequest.isCommonAssetRequest,
matchRequestUrl: () => import_matchRequestUrl.matchRequestUrl,
onUnhandledRequest: () => import_onUnhandledRequest.onUnhandledRequest,
passthrough: () => import_passthrough.passthrough,
sse: () => import_sse.sse,
ws: () => import_ws.ws
});
module.exports = __toCommonJS(index_exports);
var import_checkGlobals = require("./utils/internal/checkGlobals");
var import_SetupApi = require("./SetupApi");
var import_RequestHandler = require("./handlers/RequestHandler");
var import_http = require("./http");
var import_HttpHandler = require("./handlers/HttpHandler");
var import_graphql = require("./graphql");
var import_GraphQLHandler = require("./handlers/GraphQLHandler");
var import_ws = require("./ws");
var import_WebSocketHandler = require("./handlers/WebSocketHandler");
var import_sse = require("./sse");
var import_matchRequestUrl = require("./utils/matching/matchRequestUrl");
var import_handleRequest = require("./utils/handleRequest");
var import_onUnhandledRequest = require("./utils/request/onUnhandledRequest");
var import_getResponse = require("./getResponse");
var import_cleanUrl = require("./utils/url/cleanUrl");
var import_HttpResponse = require("./HttpResponse");
var import_delay = require("./delay");
var import_bypass = require("./bypass");
var import_passthrough = require("./passthrough");
var import_isCommonAssetRequest = require("./isCommonAssetRequest");
(0, import_checkGlobals.checkGlobals)();
//# sourceMappingURL=index.js.map

1
node_modules/msw/lib/core/index.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../src/core/index.ts"],"sourcesContent":["import { checkGlobals } from './utils/internal/checkGlobals'\n\nexport { SetupApi } from './SetupApi'\n\n/* HTTP handlers */\nexport { RequestHandler } from './handlers/RequestHandler'\nexport { http } from './http'\nexport { HttpHandler, HttpMethods } from './handlers/HttpHandler'\nexport { graphql } from './graphql'\nexport { GraphQLHandler } from './handlers/GraphQLHandler'\n\n/* WebSocket handler */\nexport { ws, type WebSocketLink } from './ws'\nexport {\n WebSocketHandler,\n type WebSocketHandlerEventMap,\n type WebSocketHandlerConnection,\n} from './handlers/WebSocketHandler'\n\n/* Server-Sent Events */\nexport {\n sse,\n type ServerSentEventRequestHandler,\n type ServerSentEventResolver,\n type ServerSentEventResolverExtras,\n type ServerSentEventMessage,\n} from './sse'\n\nimport type { HttpHandler } from './handlers/HttpHandler'\nimport type { GraphQLHandler } from './handlers/GraphQLHandler'\nimport type { WebSocketHandler } from './handlers/WebSocketHandler'\n\nexport type AnyHandler = HttpHandler | GraphQLHandler | WebSocketHandler\n\n/* Utils */\nexport { matchRequestUrl } from './utils/matching/matchRequestUrl'\nexport { handleRequest, type HandleRequestOptions } from './utils/handleRequest'\nexport {\n onUnhandledRequest,\n type UnhandledRequestStrategy,\n type UnhandledRequestCallback,\n} from './utils/request/onUnhandledRequest'\nexport { getResponse } from './getResponse'\nexport { cleanUrl } from './utils/url/cleanUrl'\n\n/**\n * Type definitions.\n */\n\nexport type { SharedOptions, LifeCycleEventsMap } from './sharedOptions'\n\nexport type {\n ResponseResolver,\n ResponseResolverReturnType,\n AsyncResponseResolverReturnType,\n RequestHandlerOptions,\n DefaultBodyType,\n DefaultRequestMultipartBody,\n JsonBodyType,\n ResponseResolverInfo,\n} from './handlers/RequestHandler'\n\nexport type {\n RequestQuery,\n HttpRequestParsedResult,\n HttpHandlerInfo,\n HttpRequestResolverExtras,\n HttpHandlerMethod,\n HttpCustomPredicate,\n} from './handlers/HttpHandler'\nexport type { HttpRequestHandler, HttpResponseResolver } from './http'\n\nexport type {\n GraphQLQuery,\n GraphQLVariables,\n GraphQLRequestBody,\n GraphQLResponseBody,\n GraphQLJsonRequestBody,\n GraphQLOperationType,\n GraphQLCustomPredicate,\n} from './handlers/GraphQLHandler'\nexport type {\n GraphQLRequestHandler,\n GraphQLOperationHandler,\n GraphQLResponseResolver,\n GraphQLLinkHandlers,\n} from './graphql'\n\nexport type { WebSocketData, WebSocketEventListener } from './ws'\n\nexport type { Path, PathParams, Match } from './utils/matching/matchRequestUrl'\nexport type { ParsedGraphQLRequest } from './utils/internal/parseGraphQLRequest'\nexport type { ResponseResolutionContext } from './utils/executeHandlers'\n\nexport {\n HttpResponse,\n type HttpResponseInit,\n type StrictRequest,\n type StrictResponse,\n} from './HttpResponse'\nexport { delay, type DelayMode } from './delay'\nexport { bypass } from './bypass'\nexport { passthrough } from './passthrough'\nexport { isCommonAssetRequest } from './isCommonAssetRequest'\n\n// Validate environmental globals before executing any code.\n// This ensures that the library gives user-friendly errors\n// when ran in the environments that require additional polyfills\n// from the end user.\ncheckGlobals()\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0BAA6B;AAE7B,sBAAyB;AAGzB,4BAA+B;AAC/B,kBAAqB;AACrB,yBAAyC;AACzC,qBAAwB;AACxB,4BAA+B;AAG/B,gBAAuC;AACvC,8BAIO;AAGP,iBAMO;AASP,6BAAgC;AAChC,2BAAyD;AACzD,gCAIO;AACP,yBAA4B;AAC5B,sBAAyB;AAmDzB,0BAKO;AACP,mBAAsC;AACtC,oBAAuB;AACvB,yBAA4B;AAC5B,kCAAqC;AAAA,IAMrC,kCAAa;","names":[]}

52
node_modules/msw/lib/core/index.mjs generated vendored Normal file
View File

@@ -0,0 +1,52 @@
import { checkGlobals } from './utils/internal/checkGlobals.mjs';
import { SetupApi } from './SetupApi.mjs';
import { RequestHandler } from './handlers/RequestHandler.mjs';
import { http } from './http.mjs';
import { HttpHandler, HttpMethods } from './handlers/HttpHandler.mjs';
import { graphql } from './graphql.mjs';
import { GraphQLHandler } from './handlers/GraphQLHandler.mjs';
import { ws } from './ws.mjs';
import {
WebSocketHandler
} from './handlers/WebSocketHandler.mjs';
import {
sse
} from './sse.mjs';
import { matchRequestUrl } from './utils/matching/matchRequestUrl.mjs';
import { handleRequest } from './utils/handleRequest.mjs';
import {
onUnhandledRequest
} from './utils/request/onUnhandledRequest.mjs';
import { getResponse } from './getResponse.mjs';
import { cleanUrl } from './utils/url/cleanUrl.mjs';
import {
HttpResponse
} from './HttpResponse.mjs';
import { delay } from './delay.mjs';
import { bypass } from './bypass.mjs';
import { passthrough } from './passthrough.mjs';
import { isCommonAssetRequest } from './isCommonAssetRequest.mjs';
checkGlobals();
export {
GraphQLHandler,
HttpHandler,
HttpMethods,
HttpResponse,
RequestHandler,
SetupApi,
WebSocketHandler,
bypass,
cleanUrl,
delay,
getResponse,
graphql,
handleRequest,
http,
isCommonAssetRequest,
matchRequestUrl,
onUnhandledRequest,
passthrough,
sse,
ws
};
//# sourceMappingURL=index.mjs.map

1
node_modules/msw/lib/core/index.mjs.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../src/core/index.ts"],"sourcesContent":["import { checkGlobals } from './utils/internal/checkGlobals'\n\nexport { SetupApi } from './SetupApi'\n\n/* HTTP handlers */\nexport { RequestHandler } from './handlers/RequestHandler'\nexport { http } from './http'\nexport { HttpHandler, HttpMethods } from './handlers/HttpHandler'\nexport { graphql } from './graphql'\nexport { GraphQLHandler } from './handlers/GraphQLHandler'\n\n/* WebSocket handler */\nexport { ws, type WebSocketLink } from './ws'\nexport {\n WebSocketHandler,\n type WebSocketHandlerEventMap,\n type WebSocketHandlerConnection,\n} from './handlers/WebSocketHandler'\n\n/* Server-Sent Events */\nexport {\n sse,\n type ServerSentEventRequestHandler,\n type ServerSentEventResolver,\n type ServerSentEventResolverExtras,\n type ServerSentEventMessage,\n} from './sse'\n\nimport type { HttpHandler } from './handlers/HttpHandler'\nimport type { GraphQLHandler } from './handlers/GraphQLHandler'\nimport type { WebSocketHandler } from './handlers/WebSocketHandler'\n\nexport type AnyHandler = HttpHandler | GraphQLHandler | WebSocketHandler\n\n/* Utils */\nexport { matchRequestUrl } from './utils/matching/matchRequestUrl'\nexport { handleRequest, type HandleRequestOptions } from './utils/handleRequest'\nexport {\n onUnhandledRequest,\n type UnhandledRequestStrategy,\n type UnhandledRequestCallback,\n} from './utils/request/onUnhandledRequest'\nexport { getResponse } from './getResponse'\nexport { cleanUrl } from './utils/url/cleanUrl'\n\n/**\n * Type definitions.\n */\n\nexport type { SharedOptions, LifeCycleEventsMap } from './sharedOptions'\n\nexport type {\n ResponseResolver,\n ResponseResolverReturnType,\n AsyncResponseResolverReturnType,\n RequestHandlerOptions,\n DefaultBodyType,\n DefaultRequestMultipartBody,\n JsonBodyType,\n ResponseResolverInfo,\n} from './handlers/RequestHandler'\n\nexport type {\n RequestQuery,\n HttpRequestParsedResult,\n HttpHandlerInfo,\n HttpRequestResolverExtras,\n HttpHandlerMethod,\n HttpCustomPredicate,\n} from './handlers/HttpHandler'\nexport type { HttpRequestHandler, HttpResponseResolver } from './http'\n\nexport type {\n GraphQLQuery,\n GraphQLVariables,\n GraphQLRequestBody,\n GraphQLResponseBody,\n GraphQLJsonRequestBody,\n GraphQLOperationType,\n GraphQLCustomPredicate,\n} from './handlers/GraphQLHandler'\nexport type {\n GraphQLRequestHandler,\n GraphQLOperationHandler,\n GraphQLResponseResolver,\n GraphQLLinkHandlers,\n} from './graphql'\n\nexport type { WebSocketData, WebSocketEventListener } from './ws'\n\nexport type { Path, PathParams, Match } from './utils/matching/matchRequestUrl'\nexport type { ParsedGraphQLRequest } from './utils/internal/parseGraphQLRequest'\nexport type { ResponseResolutionContext } from './utils/executeHandlers'\n\nexport {\n HttpResponse,\n type HttpResponseInit,\n type StrictRequest,\n type StrictResponse,\n} from './HttpResponse'\nexport { delay, type DelayMode } from './delay'\nexport { bypass } from './bypass'\nexport { passthrough } from './passthrough'\nexport { isCommonAssetRequest } from './isCommonAssetRequest'\n\n// Validate environmental globals before executing any code.\n// This ensures that the library gives user-friendly errors\n// when ran in the environments that require additional polyfills\n// from the end user.\ncheckGlobals()\n"],"mappings":"AAAA,SAAS,oBAAoB;AAE7B,SAAS,gBAAgB;AAGzB,SAAS,sBAAsB;AAC/B,SAAS,YAAY;AACrB,SAAS,aAAa,mBAAmB;AACzC,SAAS,eAAe;AACxB,SAAS,sBAAsB;AAG/B,SAAS,UAA8B;AACvC;AAAA,EACE;AAAA,OAGK;AAGP;AAAA,EACE;AAAA,OAKK;AASP,SAAS,uBAAuB;AAChC,SAAS,qBAAgD;AACzD;AAAA,EACE;AAAA,OAGK;AACP,SAAS,mBAAmB;AAC5B,SAAS,gBAAgB;AAmDzB;AAAA,EACE;AAAA,OAIK;AACP,SAAS,aAA6B;AACtC,SAAS,cAAc;AACvB,SAAS,mBAAmB;AAC5B,SAAS,4BAA4B;AAMrC,aAAa;","names":[]}

20
node_modules/msw/lib/core/isCommonAssetRequest.d.mts generated vendored Normal file
View File

@@ -0,0 +1,20 @@
/**
* Determines if the given request is a static asset request.
* Useful when deciding which unhandled requests to ignore.
* @note Despite being ignored, you can still intercept and mock
* static assets by creating request handlers for them.
*
* @example
* import { isCommonAssetRequest } from 'msw'
*
* await worker.start({
* onUnhandledRequest(request, print) {
* if (!isCommonAssetRequest(request)) {
* print.warning()
* }
* }
* })
*/
declare function isCommonAssetRequest(request: Request): boolean;
export { isCommonAssetRequest };

20
node_modules/msw/lib/core/isCommonAssetRequest.d.ts generated vendored Normal file
View File

@@ -0,0 +1,20 @@
/**
* Determines if the given request is a static asset request.
* Useful when deciding which unhandled requests to ignore.
* @note Despite being ignored, you can still intercept and mock
* static assets by creating request handlers for them.
*
* @example
* import { isCommonAssetRequest } from 'msw'
*
* await worker.start({
* onUnhandledRequest(request, print) {
* if (!isCommonAssetRequest(request)) {
* print.warning()
* }
* }
* })
*/
declare function isCommonAssetRequest(request: Request): boolean;
export { isCommonAssetRequest };

42
node_modules/msw/lib/core/isCommonAssetRequest.js generated vendored Normal file
View File

@@ -0,0 +1,42 @@
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var isCommonAssetRequest_exports = {};
__export(isCommonAssetRequest_exports, {
isCommonAssetRequest: () => isCommonAssetRequest
});
module.exports = __toCommonJS(isCommonAssetRequest_exports);
function isCommonAssetRequest(request) {
const url = new URL(request.url);
if (url.protocol === "file:") {
return true;
}
if (/(fonts\.googleapis\.com)/.test(url.hostname)) {
return true;
}
if (/node_modules/.test(url.pathname)) {
return true;
}
if (url.pathname.includes("@vite")) {
return true;
}
return /\.(s?css|less|m?jsx?|m?tsx?|html|ttf|otf|woff|woff2|eot|gif|jpe?g|png|avif|webp|svg|mp4|webm|ogg|mov|mp3|wav|ogg|flac|aac|pdf|txt|csv|json|xml|md|zip|tar|gz|rar|7z)$/i.test(
url.pathname
);
}
//# sourceMappingURL=isCommonAssetRequest.js.map

View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../src/core/isCommonAssetRequest.ts"],"sourcesContent":["/**\n * Determines if the given request is a static asset request.\n * Useful when deciding which unhandled requests to ignore.\n * @note Despite being ignored, you can still intercept and mock\n * static assets by creating request handlers for them.\n *\n * @example\n * import { isCommonAssetRequest } from 'msw'\n *\n * await worker.start({\n * onUnhandledRequest(request, print) {\n * if (!isCommonAssetRequest(request)) {\n * print.warning()\n * }\n * }\n * })\n */\nexport function isCommonAssetRequest(request: Request): boolean {\n const url = new URL(request.url)\n\n // Ignore certain protocols.\n if (url.protocol === 'file:') {\n return true\n }\n\n // Ignore static assets hosts.\n if (/(fonts\\.googleapis\\.com)/.test(url.hostname)) {\n return true\n }\n\n // Ignore node modules served over HTTP.\n if (/node_modules/.test(url.pathname)) {\n return true\n }\n\n // Ignore internal Vite requests, like \"/@vite/client\".\n if (url.pathname.includes('@vite')) {\n return true\n }\n\n // Ignore common static assets.\n return /\\.(s?css|less|m?jsx?|m?tsx?|html|ttf|otf|woff|woff2|eot|gif|jpe?g|png|avif|webp|svg|mp4|webm|ogg|mov|mp3|wav|ogg|flac|aac|pdf|txt|csv|json|xml|md|zip|tar|gz|rar|7z)$/i.test(\n url.pathname,\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBO,SAAS,qBAAqB,SAA2B;AAC9D,QAAM,MAAM,IAAI,IAAI,QAAQ,GAAG;AAG/B,MAAI,IAAI,aAAa,SAAS;AAC5B,WAAO;AAAA,EACT;AAGA,MAAI,2BAA2B,KAAK,IAAI,QAAQ,GAAG;AACjD,WAAO;AAAA,EACT;AAGA,MAAI,eAAe,KAAK,IAAI,QAAQ,GAAG;AACrC,WAAO;AAAA,EACT;AAGA,MAAI,IAAI,SAAS,SAAS,OAAO,GAAG;AAClC,WAAO;AAAA,EACT;AAGA,SAAO,yKAAyK;AAAA,IAC9K,IAAI;AAAA,EACN;AACF;","names":[]}

Some files were not shown because too many files have changed in this diff Show More