msw 2.12.13 → 2.13.0

package/lib/core/handlers/common.d.ts

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

package/lib/core/handlers/common.js.map

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

package/lib/core/handlers/common.mjs

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

package/lib/core/handlers/common.mjs.map

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

package/src/browser/setupWorker/setupWorker.ts

@@ -1,184 +0,0 @@
-import { invariant } from 'outvariant'
-import { isNodeProcess } from 'is-node-process'
-import { DeferredPromise } from '@open-draft/deferred-promise'
-import type {
-  SetupWorkerInternalContext,
-  StartReturnType,
-  StartOptions,
-  SetupWorker,
-} from './glossary'
-import { RequestHandler } from '~/core/handlers/RequestHandler'
-import { DEFAULT_START_OPTIONS } from './start/utils/prepareStartHandler'
-import { createStartHandler } from './start/createStartHandler'
-import { devUtils } from '~/core/utils/internal/devUtils'
-import { SetupApi } from '~/core/SetupApi'
-import { mergeRight } from '~/core/utils/internal/mergeRight'
-import type { LifeCycleEventsMap } from '~/core/sharedOptions'
-import type { WebSocketHandler } from '~/core/handlers/WebSocketHandler'
-import { webSocketInterceptor } from '~/core/ws/webSocketInterceptor'
-import { handleWebSocketEvent } from '~/core/ws/handleWebSocketEvent'
-import { attachWebSocketLogger } from '~/core/ws/utils/attachWebSocketLogger'
-import { WorkerChannel } from '../utils/workerChannel'
-import { createFallbackRequestListener } from './start/createFallbackRequestListener'
-import { printStartMessage } from './start/utils/printStartMessage'
-import { printStopMessage } from './stop/utils/printStopMessage'
-import { supportsServiceWorker } from '../utils/supports'
-
-export class SetupWorkerApi
-  extends SetupApi<LifeCycleEventsMap>
-  implements SetupWorker
-{
-  private context: SetupWorkerInternalContext
-
-  constructor(...handlers: Array<RequestHandler | WebSocketHandler>) {
-    super(...handlers)
-
-    invariant(
-      !isNodeProcess(),
-      devUtils.formatMessage(
-        'Failed to execute `setupWorker` in a non-browser environment. Consider using `setupServer` for Node.js environment instead.',
-      ),
-    )
-
-    this.context = this.createWorkerContext()
-  }
-
-  private createWorkerContext(): SetupWorkerInternalContext {
-    const workerPromise = new DeferredPromise<ServiceWorker>()
-
-    return {
-      // Mocking is not considered enabled until the worker
-      // signals back the successful activation event.
-      isMockingEnabled: false,
-      startOptions: null as any,
-      workerPromise,
-      registration: undefined,
-      getRequestHandlers: () => {
-        return this.handlersController.currentHandlers()
-      },
-      emitter: this.emitter,
-      workerChannel: new WorkerChannel({
-        worker: workerPromise,
-      }),
-    }
-  }
-
-  public async start(options: StartOptions = {}): StartReturnType {
-    if ('waitUntilReady' in options) {
-      devUtils.warn(
-        'The "waitUntilReady" option has been deprecated. Please remove it from this "worker.start()" call. Follow the recommended Browser integration (https://mswjs.io/docs/integrations/browser) to eliminate any race conditions between the Service Worker registration and any requests made by your application on initial render.',
-      )
-    }
-
-    // Warn the developer on multiple "worker.start()" calls.
-    // While this will not affect the worker in any way,
-    // it likely indicates an issue with the developer's code.
-    if (this.context.isMockingEnabled) {
-      devUtils.warn(
-        `Found a redundant "worker.start()" call. Note that starting the worker while mocking is already enabled will have no effect. Consider removing this "worker.start()" call.`,
-      )
-      return this.context.registration
-    }
-
-    this.context.workerStoppedAt = undefined
-
-    this.context.startOptions = mergeRight(
-      DEFAULT_START_OPTIONS,
-      options,
-    ) as SetupWorkerInternalContext['startOptions']
-
-    // Enable the WebSocket interception.
-    handleWebSocketEvent({
-      getUnhandledRequestStrategy: () => {
-        return this.context.startOptions.onUnhandledRequest
-      },
-      getHandlers: () => {
-        return this.handlersController.currentHandlers()
-      },
-      onMockedConnection: (connection) => {
-        if (!this.context.startOptions.quiet) {
-          // Attach the logger for mocked connections since
-          // those won't be visible in the browser's devtools.
-          attachWebSocketLogger(connection)
-        }
-      },
-      onPassthroughConnection() {},
-    })
-    webSocketInterceptor.apply()
-
-    this.subscriptions.push(() => {
-      webSocketInterceptor.dispose()
-    })
-
-    // Use a fallback interception algorithm in the environments
-    // where the Service Worker API isn't supported.
-    if (!supportsServiceWorker()) {
-      const fallbackInterceptor = createFallbackRequestListener(
-        this.context,
-        this.context.startOptions,
-      )
-
-      this.subscriptions.push(() => {
-        fallbackInterceptor.dispose()
-      })
-
-      this.context.isMockingEnabled = true
-
-      printStartMessage({
-        message: 'Mocking enabled (fallback mode).',
-        quiet: this.context.startOptions.quiet,
-      })
-
-      return undefined
-    }
-
-    const startHandler = createStartHandler(this.context)
-    const registration = await startHandler(this.context.startOptions, options)
-
-    this.context.isMockingEnabled = true
-
-    return registration
-  }
-
-  public stop(): void {
-    super.dispose()
-
-    if (!this.context.isMockingEnabled) {
-      devUtils.warn(
-        'Found a redundant "worker.stop()" call. Notice that stopping the worker after it has already been stopped has no effect. Consider removing this "worker.stop()" call.',
-      )
-      return
-    }
-
-    this.context.isMockingEnabled = false
-    this.context.workerStoppedAt = Date.now()
-    this.context.emitter.removeAllListeners()
-
-    if (supportsServiceWorker()) {
-      this.context.workerChannel.removeAllListeners('RESPONSE')
-      window.clearInterval(this.context.keepAliveInterval)
-    }
-
-    // Post the internal stop message on the window
-    // to let any logic know when the worker has stopped.
-    // E.g. the WebSocket client manager needs this to know
-    // when to clear its in-memory clients list.
-    window.postMessage({ type: 'msw/worker:stop' })
-
-    printStopMessage({
-      quiet: this.context.startOptions?.quiet,
-    })
-  }
-}
-
-/**
- * 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}
- */
-export function setupWorker(
-  ...handlers: Array<RequestHandler | WebSocketHandler>
-): SetupWorker {
-  return new SetupWorkerApi(...handlers)
-}

package/src/browser/setupWorker/start/createFallbackRequestListener.ts

@@ -1,71 +0,0 @@
-import {
-  Interceptor,
-  BatchInterceptor,
-  HttpRequestEventMap,
-} from '@mswjs/interceptors'
-import { FetchInterceptor } from '@mswjs/interceptors/fetch'
-import { XMLHttpRequestInterceptor } from '@mswjs/interceptors/XMLHttpRequest'
-import { SetupWorkerInternalContext, StartOptions } from '../glossary'
-import type { RequiredDeep } from '~/core/typeUtils'
-import { handleRequest } from '~/core/utils/handleRequest'
-import { isHandlerKind } from '~/core/utils/internal/isHandlerKind'
-
-export function createFallbackRequestListener(
-  context: SetupWorkerInternalContext,
-  options: RequiredDeep<StartOptions>,
-): Interceptor<HttpRequestEventMap> {
-  const interceptor = new BatchInterceptor({
-    name: 'fallback',
-    interceptors: [new FetchInterceptor(), new XMLHttpRequestInterceptor()],
-  })
-
-  interceptor.on('request', async ({ request, requestId, controller }) => {
-    const requestCloneForLogs = request.clone()
-
-    const response = await handleRequest(
-      request,
-      requestId,
-      context.getRequestHandlers().filter(isHandlerKind('RequestHandler')),
-      options,
-      context.emitter,
-      {
-        resolutionContext: {
-          quiet: options.quiet,
-        },
-        onMockedResponse(_, { handler, parsedResult }) {
-          if (!options.quiet) {
-            context.emitter.once('response:mocked', ({ response }) => {
-              handler.log({
-                request: requestCloneForLogs,
-                response,
-                parsedResult,
-              })
-            })
-          }
-        },
-      },
-    )
-
-    if (response) {
-      controller.respondWith(response)
-    }
-  })
-
-  interceptor.on(
-    'response',
-    ({ response, isMockedResponse, request, requestId }) => {
-      context.emitter.emit(
-        isMockedResponse ? 'response:mocked' : 'response:bypass',
-        {
-          response,
-          request,
-          requestId,
-        },
-      )
-    },
-  )
-
-  interceptor.apply()
-
-  return interceptor
-}

package/src/browser/setupWorker/start/createRequestListener.ts

@@ -1,138 +0,0 @@
-import { Emitter } from 'rettime'
-import { StartOptions, SetupWorkerInternalContext } from '../glossary'
-import { deserializeRequest } from '../../utils/deserializeRequest'
-import { supportsReadableStreamTransfer } from '../../utils/supports'
-import { RequestHandler } from '~/core/handlers/RequestHandler'
-import { handleRequest } from '~/core/utils/handleRequest'
-import { RequiredDeep } from '~/core/typeUtils'
-import { devUtils } from '~/core/utils/internal/devUtils'
-import { toResponseInit } from '~/core/utils/toResponseInit'
-import { isHandlerKind } from '~/core/utils/internal/isHandlerKind'
-
-const SUPPORTS_READABLE_STREAM_TRANSFER = supportsReadableStreamTransfer()
-
-export const createRequestListener = (
-  context: SetupWorkerInternalContext,
-  options: RequiredDeep<StartOptions>,
-): Emitter.ListenerType<typeof context.workerChannel, 'REQUEST'> => {
-  return async (event) => {
-    // Treat any incoming requests from the worker as passthrough
-    // if `worker.stop()` has been called for this client.
-    if (
-      !context.isMockingEnabled &&
-      context.workerStoppedAt &&
-      event.data.interceptedAt > context.workerStoppedAt
-    ) {
-      event.postMessage('PASSTHROUGH')
-      return
-    }
-
-    const requestId = event.data.id
-    const request = deserializeRequest(event.data)
-    const requestCloneForLogs = request.clone()
-
-    // Make this the first request clone before the
-    // request resolution pipeline even starts.
-    // Store the clone in cache so the first matching
-    // request handler would skip the cloning phase.
-    const requestClone = request.clone()
-    RequestHandler.cache.set(request, requestClone)
-
-    try {
-      await handleRequest(
-        request,
-        requestId,
-        context.getRequestHandlers().filter(isHandlerKind('RequestHandler')),
-        options,
-        context.emitter,
-        {
-          resolutionContext: {
-            quiet: options.quiet,
-          },
-          onPassthroughResponse() {
-            event.postMessage('PASSTHROUGH')
-          },
-          async onMockedResponse(response, { handler, parsedResult }) {
-            // Clone the mocked response so its body could be read
-            // to buffer to be sent to the worker and also in the
-            // ".log()" method of the request handler.
-            const responseClone = response.clone()
-            const responseCloneForLogs = response.clone()
-            const responseInit = toResponseInit(response)
-
-            /**
-             * @note Safari doesn't support transferring a "ReadableStream".
-             * Check that the browser supports that before sending it to the worker.
-             */
-            if (SUPPORTS_READABLE_STREAM_TRANSFER) {
-              const responseStreamOrNull = response.body
-
-              event.postMessage(
-                'MOCK_RESPONSE',
-                {
-                  ...responseInit,
-                  body: responseStreamOrNull,
-                },
-                responseStreamOrNull ? [responseStreamOrNull] : undefined,
-              )
-            } else {
-              /**
-               * @note If we are here, this means the current environment doesn't
-               * support "ReadableStream" as transferable. In that case,
-               * attempt to read the non-empty response body as ArrayBuffer, if it's not empty.
-               * @see https://github.com/mswjs/msw/issues/1827
-               */
-              const responseBufferOrNull =
-                response.body === null
-                  ? null
-                  : await responseClone.arrayBuffer()
-
-              event.postMessage('MOCK_RESPONSE', {
-                ...responseInit,
-                body: responseBufferOrNull,
-              })
-            }
-
-            if (!options.quiet) {
-              context.emitter.once('response:mocked', () => {
-                handler.log({
-                  request: requestCloneForLogs,
-                  response: responseCloneForLogs,
-                  parsedResult,
-                })
-              })
-            }
-          },
-        },
-      )
-    } catch (error) {
-      if (error instanceof Error) {
-        devUtils.error(
-          `Uncaught exception in the request handler for "%s %s":
-
-%s
-
-This exception has been gracefully handled as a 500 response, however, it's strongly recommended to resolve this error, as it indicates a mistake in your code. If you wish to mock an error response, please see this guide: https://mswjs.io/docs/http/mocking-responses/error-responses`,
-          request.method,
-          request.url,
-          error.stack ?? error,
-        )
-
-        // Treat all other exceptions in a request handler as unintended,
-        // alerting that there is a problem that needs fixing.
-        event.postMessage('MOCK_RESPONSE', {
-          status: 500,
-          statusText: 'Request Handler Error',
-          headers: {
-            'Content-Type': 'application/json',
-          },
-          body: JSON.stringify({
-            name: error.name,
-            message: error.message,
-            stack: error.stack,
-          }),
-        })
-      }
-    }
-  }
-}

package/src/browser/setupWorker/start/createResponseListener.ts

@@ -1,57 +0,0 @@
-import { FetchResponse } from '@mswjs/interceptors'
-import type { Emitter } from 'rettime'
-import type { SetupWorkerInternalContext } from '../glossary'
-import { deserializeRequest } from '../../utils/deserializeRequest'
-
-export function createResponseListener(
-  context: SetupWorkerInternalContext,
-): Emitter.ListenerType<typeof context.workerChannel, 'RESPONSE'> {
-  return (event) => {
-    const responseMessage = event.data
-    const request = deserializeRequest(responseMessage.request)
-
-    /**
-     * CORS requests with `mode: "no-cors"` result in "opaque" responses.
-     * That kind of responses cannot be manipulated in JavaScript due
-     * to the security considerations.
-     * @see https://fetch.spec.whatwg.org/#concept-filtered-response-opaque
-     * @see https://github.com/mswjs/msw/issues/529
-     */
-    if (responseMessage.response.type?.includes('opaque')) {
-      return
-    }
-
-    const response =
-      responseMessage.response.status === 0
-        ? Response.error()
-        : new FetchResponse(
-            /**
-             * Responses may be streams here, but when we create a response object
-             * with null-body status codes, like 204, 205, 304 Response will
-             * throw when passed a non-null body, so ensure it's null here
-             * for those codes
-             */
-            FetchResponse.isResponseWithBody(responseMessage.response.status)
-              ? responseMessage.response.body
-              : null,
-            {
-              ...responseMessage.response,
-              /**
-               * Set response URL if it's not set already.
-               * @see https://github.com/mswjs/msw/issues/2030
-               * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/url
-               */
-              url: request.url,
-            },
-          )
-
-    context.emitter.emit(
-      responseMessage.isMockedResponse ? 'response:mocked' : 'response:bypass',
-      {
-        requestId: responseMessage.request.id,
-        request,
-        response,
-      },
-    )
-  }
-}

package/src/browser/setupWorker/start/createStartHandler.ts

@@ -1,137 +0,0 @@
-import { devUtils } from '~/core/utils/internal/devUtils'
-import { getWorkerInstance } from './utils/getWorkerInstance'
-import { enableMocking } from './utils/enableMocking'
-import type { SetupWorkerInternalContext, StartHandler } from '../glossary'
-import { createRequestListener } from './createRequestListener'
-import { checkWorkerIntegrity } from '../../utils/checkWorkerIntegrity'
-import { createResponseListener } from './createResponseListener'
-import { validateWorkerScope } from './utils/validateWorkerScope'
-import { DeferredPromise } from '@open-draft/deferred-promise'
-
-export const createStartHandler = (
-  context: SetupWorkerInternalContext,
-): StartHandler => {
-  return function start(options, customOptions) {
-    const startWorkerInstance = async () => {
-      // Remove all previously existing event listeners.
-      // This way none of the listeners persists between Fast refresh
-      // of the application's code.
-      context.workerChannel.removeAllListeners()
-
-      // Handle requests signaled by the worker.
-      context.workerChannel.on(
-        'REQUEST',
-        createRequestListener(context, options),
-      )
-
-      // Handle responses signaled by the worker.
-      context.workerChannel.on('RESPONSE', createResponseListener(context))
-
-      const instance = await getWorkerInstance(
-        options.serviceWorker.url,
-        options.serviceWorker.options,
-        options.findWorker,
-      )
-
-      const [worker, registration] = instance
-
-      if (!worker) {
-        const missingWorkerMessage = customOptions?.findWorker
-          ? devUtils.formatMessage(
-              `Failed to locate the Service Worker registration using a custom "findWorker" predicate.
-
-Please ensure that the custom predicate properly locates the Service Worker registration at "%s".
-More details: https://mswjs.io/docs/api/setup-worker/start#findworker
-`,
-              options.serviceWorker.url,
-            )
-          : devUtils.formatMessage(
-              `Failed to locate the Service Worker registration.
-
-This most likely means that the worker script URL "%s" cannot resolve against the actual public hostname (%s). This may happen if your application runs behind a proxy, or has a dynamic hostname.
-
-Please consider using a custom "serviceWorker.url" option to point to the actual worker script location, or a custom "findWorker" option to resolve the Service Worker registration manually. More details: https://mswjs.io/docs/api/setup-worker/start`,
-              options.serviceWorker.url,
-              location.host,
-            )
-
-        throw new Error(missingWorkerMessage)
-      }
-
-      context.workerPromise.resolve(worker)
-      context.registration = registration
-
-      window.addEventListener('beforeunload', () => {
-        if (worker.state !== 'redundant') {
-          // Notify the Service Worker that this client has closed.
-          // Internally, it's similar to disabling the mocking, only
-          // client close event has a handler that self-terminates
-          // the Service Worker when there are no open clients.
-          context.workerChannel.postMessage('CLIENT_CLOSED')
-        }
-
-        // Make sure we're always clearing the interval - there are reports that not doing this can
-        // cause memory leaks in headless browser environments.
-        window.clearInterval(context.keepAliveInterval)
-
-        // Notify others about this client disconnecting.
-        // E.g. this will purge the in-memory WebSocket clients since
-        // starting the worker again will assign them new IDs.
-        window.postMessage({ type: 'msw/worker:stop' })
-      })
-
-      // Check if the active Service Worker has been generated
-      // by the currently installed version of MSW.
-      await checkWorkerIntegrity(context).catch((error) => {
-        devUtils.error(
-          'Error while checking the worker script integrity. Please report this on GitHub (https://github.com/mswjs/msw/issues) and include the original error below.',
-        )
-        console.error(error)
-      })
-
-      context.keepAliveInterval = window.setInterval(
-        () => context.workerChannel.postMessage('KEEPALIVE_REQUEST'),
-        5000,
-      )
-
-      // Warn the user when loading the page that lies outside
-      // of the worker's scope.
-      validateWorkerScope(registration, context.startOptions)
-
-      return registration
-    }
-
-    const workerRegistration = startWorkerInstance().then(
-      async (registration) => {
-        const pendingInstance = registration.installing || registration.waiting
-
-        if (pendingInstance) {
-          const activationPromise = new DeferredPromise<void>()
-
-          pendingInstance.addEventListener('statechange', () => {
-            if (pendingInstance.state === 'activated') {
-              activationPromise.resolve()
-            }
-          })
-
-          // Wait until the worker is activated.
-          // Assume the worker is already activated if there's no pending registration
-          // (i.e. when reloading the page after a successful activation).
-          await activationPromise
-        }
-
-        // Print the activation message only after the worker has been activated.
-        await enableMocking(context, options).catch((error) => {
-          devUtils.error(
-            'Failed to enable mocking. Please report this on GitHub (https://github.com/mswjs/msw/issues) and include the original error below.',
-          )
-          throw error
-        })
-
-        return registration
-      },
-    )
-
-    return workerRegistration
-  }
-}

package/src/browser/setupWorker/start/utils/enableMocking.ts

@@ -1,30 +0,0 @@
-import { DeferredPromise } from '@open-draft/deferred-promise'
-import type { StartOptions, SetupWorkerInternalContext } from '../../glossary'
-import { printStartMessage } from './printStartMessage'
-
-/**
- * Signals the worker to enable the interception of requests.
- */
-export function enableMocking(
-  context: SetupWorkerInternalContext,
-  options: StartOptions,
-): Promise<boolean> {
-  const mockingEnabledPromise = new DeferredPromise<boolean>()
-
-  context.workerChannel.postMessage('MOCK_ACTIVATE')
-  context.workerChannel.once('MOCKING_ENABLED', async (event) => {
-    context.isMockingEnabled = true
-    const worker = await context.workerPromise
-
-    printStartMessage({
-      quiet: options.quiet,
-      workerScope: context.registration?.scope,
-      workerUrl: worker.scriptURL,
-      client: event.data.client,
-    })
-
-    mockingEnabledPromise.resolve(true)
-  })
-
-  return mockingEnabledPromise
-}