msw 2.12.13 → 2.13.0

package/src/browser/setupWorker/start/utils/prepareStartHandler.test.ts

@@ -1,59 +0,0 @@
-import { SetupWorkerInternalContext, StartOptions } from '../../glossary'
-import {
-  DEFAULT_START_OPTIONS,
-  resolveStartOptions,
-  prepareStartHandler,
-} from './prepareStartHandler'
-
-describe('resolveStartOptions', () => {
-  test('returns default options given no custom start options', () => {
-    expect(resolveStartOptions()).toEqual(DEFAULT_START_OPTIONS)
-    expect(resolveStartOptions(undefined)).toEqual(DEFAULT_START_OPTIONS)
-    expect(resolveStartOptions({})).toEqual(DEFAULT_START_OPTIONS)
-  })
-
-  test('deeply merges the default and custom start options', () => {
-    expect(
-      resolveStartOptions({
-        quiet: true,
-        serviceWorker: {
-          url: './custom.js',
-        },
-      }),
-    ).toEqual({
-      ...DEFAULT_START_OPTIONS,
-      quiet: true,
-      serviceWorker: {
-        url: './custom.js',
-        options: null,
-      },
-    })
-  })
-})
-
-describe('prepareStartHandler', () => {
-  test('exposes resolved start options to the generated star handler', () => {
-    const createStartHandler = vi.fn()
-    const context: SetupWorkerInternalContext = {} as any
-    const startHandler = prepareStartHandler(createStartHandler, context)
-    expect(startHandler).toBeInstanceOf(Function)
-
-    const initialOptions: StartOptions = {
-      quiet: true,
-      serviceWorker: {
-        url: './custom.js',
-      },
-    }
-    const resolvedOptions = resolveStartOptions(initialOptions)
-    startHandler(initialOptions)
-
-    // Calls the handler creator with both resolved and initial options.
-    expect(createStartHandler).toHaveBeenCalledWith(
-      resolvedOptions,
-      initialOptions,
-    )
-
-    // Sets the resolved options on the internal context.
-    expect(context).toHaveProperty('startOptions', resolvedOptions)
-  })
-})

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

@@ -1,44 +0,0 @@
-import { RequiredDeep } from '~/core/typeUtils'
-import { mergeRight } from '~/core/utils/internal/mergeRight'
-import {
-  SetupWorker,
-  SetupWorkerInternalContext,
-  StartHandler,
-  StartOptions,
-} from '../../glossary'
-
-export const DEFAULT_START_OPTIONS: RequiredDeep<StartOptions> = {
-  serviceWorker: {
-    url: '/mockServiceWorker.js',
-    options: null as any,
-  },
-  quiet: false,
-  waitUntilReady: true,
-  onUnhandledRequest: 'warn',
-  findWorker(scriptURL, mockServiceWorkerUrl) {
-    return scriptURL === mockServiceWorkerUrl
-  },
-}
-
-/**
- * Returns resolved worker start options, merging the default options
- * with the given custom options.
- */
-export function resolveStartOptions(
-  initialOptions?: StartOptions,
-): RequiredDeep<StartOptions> {
-  return mergeRight(
-    DEFAULT_START_OPTIONS,
-    initialOptions || {},
-  ) as RequiredDeep<StartOptions>
-}
-
-export function prepareStartHandler(
-  handler: StartHandler,
-  context: SetupWorkerInternalContext,
-): SetupWorker['start'] {
-  return (initialOptions) => {
-    context.startOptions = resolveStartOptions(initialOptions)
-    return handler(context.startOptions, initialOptions || {})
-  }
-}

package/src/browser/setupWorker/start/utils/printStartMessage.test.ts

@@ -1,84 +0,0 @@
-import { printStartMessage } from './printStartMessage'
-
-beforeEach(() => {
-  vi.spyOn(console, 'groupCollapsed').mockImplementation(() => void 0)
-  vi.spyOn(console, 'log').mockImplementation(() => void 0)
-})
-
-afterEach(() => {
-  vi.restoreAllMocks()
-})
-
-test('prints out a default start message into console', () => {
-  printStartMessage({
-    workerScope: 'http://localhost:3000/',
-    workerUrl: 'http://localhost:3000/worker.js',
-  })
-
-  expect(console.groupCollapsed).toHaveBeenCalledWith(
-    '%c[MSW] Mocking enabled.',
-    expect.anything(),
-  )
-
-  // Includes a link to the documentation.
-  expect(console.log).toHaveBeenCalledWith(
-    '%cDocumentation: %chttps://mswjs.io/docs',
-    expect.anything(),
-    expect.anything(),
-  )
-
-  // Includes a link to the GitHub issues page.
-  expect(console.log).toHaveBeenCalledWith(
-    'Found an issue? https://github.com/mswjs/msw/issues',
-  )
-
-  // Includes service worker scope.
-  expect(console.log).toHaveBeenCalledWith(
-    'Worker scope:',
-    'http://localhost:3000/',
-  )
-
-  // Includes service worker script location.
-  expect(console.log).toHaveBeenCalledWith(
-    'Worker script URL:',
-    'http://localhost:3000/worker.js',
-  )
-})
-
-test('supports printing a custom start message', () => {
-  printStartMessage({ message: 'Custom start message' })
-
-  expect(console.groupCollapsed).toHaveBeenCalledWith(
-    '%c[MSW] Custom start message',
-    expect.anything(),
-  )
-})
-
-test('does not print any messages when log level is quiet', () => {
-  printStartMessage({ quiet: true })
-
-  expect(console.groupCollapsed).not.toHaveBeenCalled()
-  expect(console.log).not.toHaveBeenCalled()
-})
-
-test('prints a worker scope in the start message', () => {
-  printStartMessage({
-    workerScope: 'http://localhost:3000/user',
-  })
-
-  expect(console.log).toHaveBeenCalledWith(
-    'Worker scope:',
-    'http://localhost:3000/user',
-  )
-})
-
-test('prints a worker script url in the start message', () => {
-  printStartMessage({
-    workerUrl: 'http://localhost:3000/mockServiceWorker.js',
-  })
-
-  expect(console.log).toHaveBeenCalledWith(
-    'Worker script URL:',
-    'http://localhost:3000/mockServiceWorker.js',
-  )
-})

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

@@ -1,51 +0,0 @@
-import type { ServiceWorkerIncomingEventsMap } from '../../glossary'
-import { devUtils } from '~/core/utils/internal/devUtils'
-
-interface PrintStartMessageArgs {
-  quiet?: boolean
-  message?: string
-  workerUrl?: string
-  workerScope?: string
-  client?: ServiceWorkerIncomingEventsMap['MOCKING_ENABLED']['client']
-}
-
-/**
- * Prints a worker activation message in the browser's console.
- */
-export function printStartMessage(args: PrintStartMessageArgs = {}) {
-  if (args.quiet) {
-    return
-  }
-
-  const message = args.message || 'Mocking enabled.'
-
-  console.groupCollapsed(
-    `%c${devUtils.formatMessage(message)}`,
-    'color:orangered;font-weight:bold;',
-  )
-  // eslint-disable-next-line no-console
-  console.log(
-    '%cDocumentation: %chttps://mswjs.io/docs',
-    'font-weight:bold',
-    'font-weight:normal',
-  )
-  // eslint-disable-next-line no-console
-  console.log('Found an issue? https://github.com/mswjs/msw/issues')
-
-  if (args.workerUrl) {
-    // eslint-disable-next-line no-console
-    console.log('Worker script URL:', args.workerUrl)
-  }
-
-  if (args.workerScope) {
-    // eslint-disable-next-line no-console
-    console.log('Worker scope:', args.workerScope)
-  }
-
-  if (args.client) {
-    // eslint-disable-next-line no-console
-    console.log('Client ID: %s (%s)', args.client.id, args.client.frameType)
-  }
-
-  console.groupEnd()
-}

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

@@ -1,18 +0,0 @@
-import { devUtils } from '~/core/utils/internal/devUtils'
-import { StartOptions } from '../../glossary'
-
-export function validateWorkerScope(
-  registration: ServiceWorkerRegistration,
-  options?: StartOptions,
-): void {
-  if (!options?.quiet && !location.href.startsWith(registration.scope)) {
-    devUtils.warn(
-      `\
-Cannot intercept requests on this page because it's outside of the worker's scope ("${registration.scope}"). If you wish to mock API requests on this page, you must resolve this scope issue.
-
-- (Recommended) Register the worker at the root level ("/") of your application.
-- Set the "Service-Worker-Allowed" response header to allow out-of-scope workers.\
-`,
-    )
-  }
-}

package/src/browser/setupWorker/stop/utils/printStopMessage.test.ts

@@ -1,26 +0,0 @@
-import { printStopMessage } from './printStopMessage'
-
-beforeAll(() => {
-  vi.spyOn(global.console, 'log').mockImplementation(() => void 0)
-})
-
-afterEach(() => {
-  vi.resetAllMocks()
-})
-
-afterAll(() => {
-  vi.restoreAllMocks()
-})
-
-test('prints a stop message to the console', () => {
-  printStopMessage()
-  expect(console.log).toHaveBeenCalledWith(
-    '%c[MSW] Mocking disabled.',
-    'color:orangered;font-weight:bold;',
-  )
-})
-
-test('does not print any message when log level is quiet', () => {
-  printStopMessage({ quiet: true })
-  expect(console.log).not.toHaveBeenCalled()
-})

package/src/browser/setupWorker/stop/utils/printStopMessage.ts

@@ -1,13 +0,0 @@
-import { devUtils } from '~/core/utils/internal/devUtils'
-
-export function printStopMessage(args: { quiet?: boolean } = {}): void {
-  if (args.quiet) {
-    return
-  }
-
-  // eslint-disable-next-line no-console
-  console.log(
-    `%c${devUtils.formatMessage('Mocking disabled.')}`,
-    'color:orangered;font-weight:bold;',
-  )
-}

package/src/browser/utils/checkWorkerIntegrity.ts

@@ -1,42 +0,0 @@
-import { devUtils } from '~/core/utils/internal/devUtils'
-import type { SetupWorkerInternalContext } from '../setupWorker/glossary'
-import { DeferredPromise } from '@open-draft/deferred-promise'
-
-/**
- * Check whether the registered Service Worker has been
- * generated by the installed version of the library.
- * Prints a warning message if the worker scripts mismatch.
- */
-export function checkWorkerIntegrity(
-  context: SetupWorkerInternalContext,
-): Promise<void> {
-  const integrityCheckPromise = new DeferredPromise<void>()
-
-  // Request the integrity checksum from the registered worker.
-  context.workerChannel.postMessage('INTEGRITY_CHECK_REQUEST')
-  context.workerChannel.once('INTEGRITY_CHECK_RESPONSE', (event) => {
-    const { checksum, packageVersion } = event.data
-
-    // Compare the response from the Service Worker and the
-    // global variable set during the build.
-
-    // The integrity is validated based on the worker script's checksum
-    // that's derived from its minified content during the build.
-    // The "SERVICE_WORKER_CHECKSUM" global variable is injected by the build.
-    if (checksum !== SERVICE_WORKER_CHECKSUM) {
-      devUtils.warn(
-        `The currently registered Service Worker has been generated by a different version of MSW (${packageVersion}) and may not be fully compatible with the installed version.
-
-It's recommended you update your worker script by running this command:
-
-  \u2022 npx msw init <PUBLIC_DIR>
-
-You can also automate this process and make the worker script update automatically upon the library installations. Read more: https://mswjs.io/docs/cli/init.`,
-      )
-    }
-
-    integrityCheckPromise.resolve()
-  })
-
-  return integrityCheckPromise
-}

package/src/core/SetupApi.ts

@@ -1,127 +0,0 @@
-import { invariant } from 'outvariant'
-import { EventMap, Emitter } from 'strict-event-emitter'
-import { RequestHandler } from './handlers/RequestHandler'
-import { LifeCycleEventEmitter } from './sharedOptions'
-import { devUtils } from './utils/internal/devUtils'
-import { pipeEvents } from './utils/internal/pipeEvents'
-import { toReadonlyArray } from './utils/internal/toReadonlyArray'
-import { Disposable } from './utils/internal/Disposable'
-import type { WebSocketHandler } from './handlers/WebSocketHandler'
-
-export abstract class HandlersController {
-  abstract prepend(
-    runtimeHandlers: Array<RequestHandler | WebSocketHandler>,
-  ): void
-  abstract reset(nextHandles: Array<RequestHandler | WebSocketHandler>): void
-  abstract currentHandlers(): Array<RequestHandler | WebSocketHandler>
-}
-
-export class InMemoryHandlersController implements HandlersController {
-  private handlers: Array<RequestHandler | WebSocketHandler>
-
-  constructor(
-    private initialHandlers: Array<RequestHandler | WebSocketHandler>,
-  ) {
-    this.handlers = [...initialHandlers]
-  }
-
-  public prepend(
-    runtimeHandles: Array<RequestHandler | WebSocketHandler>,
-  ): void {
-    this.handlers.unshift(...runtimeHandles)
-  }
-
-  public reset(nextHandlers: Array<RequestHandler | WebSocketHandler>): void {
-    this.handlers =
-      nextHandlers.length > 0 ? [...nextHandlers] : [...this.initialHandlers]
-  }
-
-  public currentHandlers(): Array<RequestHandler | WebSocketHandler> {
-    return this.handlers
-  }
-}
-
-/**
- * Generic class for the mock API setup.
- */
-export abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
-  protected handlersController: HandlersController
-  protected readonly emitter: Emitter<EventsMap>
-  protected readonly publicEmitter: Emitter<EventsMap>
-
-  public readonly events: LifeCycleEventEmitter<EventsMap>
-
-  constructor(...initialHandlers: Array<RequestHandler | WebSocketHandler>) {
-    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<EventsMap>()
-    this.publicEmitter = new Emitter<EventsMap>()
-    pipeEvents(this.emitter, this.publicEmitter)
-
-    this.events = this.createLifeCycleEvents()
-
-    this.subscriptions.push(() => {
-      this.emitter.removeAllListeners()
-      this.publicEmitter.removeAllListeners()
-    })
-  }
-
-  private validateHandlers(handlers: ReadonlyArray<unknown>): boolean {
-    // Guard against incorrect call signature of the setup API.
-    return handlers.every((handler) => !Array.isArray(handler))
-  }
-
-  public use(
-    ...runtimeHandlers: Array<RequestHandler | WebSocketHandler>
-  ): void {
-    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)
-  }
-
-  public restoreHandlers(): void {
-    this.handlersController.currentHandlers().forEach((handler) => {
-      if ('isUsed' in handler) {
-        handler.isUsed = false
-      }
-    })
-  }
-
-  public resetHandlers(
-    ...nextHandlers: Array<RequestHandler | WebSocketHandler>
-  ): void {
-    this.handlersController.reset(nextHandlers)
-  }
-
-  public listHandlers(): ReadonlyArray<RequestHandler | WebSocketHandler> {
-    return toReadonlyArray(this.handlersController.currentHandlers())
-  }
-
-  private createLifeCycleEvents(): LifeCycleEventEmitter<EventsMap> {
-    return {
-      on: (...args: any[]) => {
-        return (this.publicEmitter.on as any)(...args)
-      },
-      removeListener: (...args: any[]) => {
-        return (this.publicEmitter.removeListener as any)(...args)
-      },
-      removeAllListeners: (...args: any[]) => {
-        return this.publicEmitter.removeAllListeners(...args)
-      },
-    }
-  }
-}

package/src/core/handlers/common.ts

@@ -1 +0,0 @@
-export type HandlerKind = 'RequestHandler' | 'EventHandler'

package/src/node/SetupServerApi.ts

@@ -1,87 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks'
-import type { HttpRequestEventMap, Interceptor } from '@mswjs/interceptors'
-import { ClientRequestInterceptor } from '@mswjs/interceptors/ClientRequest'
-import { XMLHttpRequestInterceptor } from '@mswjs/interceptors/XMLHttpRequest'
-import { FetchInterceptor } from '@mswjs/interceptors/fetch'
-import { HandlersController } from '~/core/SetupApi'
-import type { RequestHandler } from '~/core/handlers/RequestHandler'
-import type { WebSocketHandler } from '~/core/handlers/WebSocketHandler'
-import type { SetupServer } from './glossary'
-import { SetupServerCommonApi } from './SetupServerCommonApi'
-
-const store = new AsyncLocalStorage<RequestHandlersContext>()
-
-type RequestHandlersContext = {
-  initialHandlers: Array<RequestHandler | WebSocketHandler>
-  handlers: Array<RequestHandler | WebSocketHandler>
-}
-
-/**
- * A handlers controller that utilizes `AsyncLocalStorage` in Node.js
- * to prevent the request handlers list from being a shared state
- * across multiple tests.
- */
-class AsyncHandlersController implements HandlersController {
-  private rootContext: RequestHandlersContext
-
-  constructor(initialHandlers: Array<RequestHandler | WebSocketHandler>) {
-    this.rootContext = { initialHandlers, handlers: [] }
-  }
-
-  get context(): RequestHandlersContext {
-    return store.getStore() || this.rootContext
-  }
-
-  public prepend(runtimeHandlers: Array<RequestHandler | WebSocketHandler>) {
-    this.context.handlers.unshift(...runtimeHandlers)
-  }
-
-  public reset(nextHandlers: Array<RequestHandler | WebSocketHandler>) {
-    const context = this.context
-    context.handlers = []
-    context.initialHandlers =
-      nextHandlers.length > 0 ? nextHandlers : context.initialHandlers
-  }
-
-  public currentHandlers(): Array<RequestHandler | WebSocketHandler> {
-    const { initialHandlers, handlers } = this.context
-    return handlers.concat(initialHandlers)
-  }
-}
-export class SetupServerApi
-  extends SetupServerCommonApi
-  implements SetupServer
-{
-  constructor(
-    handlers: Array<RequestHandler | WebSocketHandler>,
-    interceptors: Array<Interceptor<HttpRequestEventMap>> = [
-      new ClientRequestInterceptor(),
-      new XMLHttpRequestInterceptor(),
-      new FetchInterceptor(),
-    ],
-  ) {
-    super(interceptors, handlers)
-
-    this.handlersController = new AsyncHandlersController(handlers)
-  }
-
-  public boundary<Args extends Array<any>, R>(
-    callback: (...args: Args) => R,
-  ): (...args: Args) => R {
-    return (...args: Args): R => {
-      return store.run<any, any>(
-        {
-          initialHandlers: this.handlersController.currentHandlers(),
-          handlers: [],
-        },
-        callback,
-        ...args,
-      )
-    }
-  }
-
-  public close(): void {
-    super.close()
-    store.disable()
-  }
-}