msw 2.14.7 → 3.0.0

package/src/core/utils/internal/isHandlerKind.test.ts

@@ -1,62 +0,0 @@
-import { GraphQLHandler } from '../../handlers/GraphQLHandler'
-import { HttpHandler } from '../../handlers/HttpHandler'
-import { RequestHandler } from '../../handlers/RequestHandler'
-import { WebSocketHandler } from '../../handlers/WebSocketHandler'
-import { isHandlerKind } from './isHandlerKind'
-
-it('returns true if expected a request handler and given a request handler', () => {
-  expect(isHandlerKind('request')(new HttpHandler('*', '*', () => {}))).toBe(
-    true,
-  )
-
-  expect(
-    isHandlerKind('request')(new GraphQLHandler('all', '*', '*', () => {})),
-  ).toBe(true)
-})
-
-it('returns true if expected a request handler and given a custom request handler', () => {
-  class MyHandler extends RequestHandler {
-    constructor() {
-      super({ info: { header: '*' }, resolver: () => {} })
-    }
-    predicate = () => false
-    log() {}
-  }
-
-  expect(isHandlerKind('request')(new MyHandler())).toBe(true)
-})
-
-it('returns false if expected a request handler but given event handler', () => {
-  expect(isHandlerKind('request')(new WebSocketHandler('*'))).toBe(false)
-})
-
-it('returns false if expected a request handler but given arbitrary object', () => {
-  expect(isHandlerKind('request')(undefined)).toBe(false)
-  expect(isHandlerKind('request')(null)).toBe(false)
-  expect(isHandlerKind('request')({})).toBe(false)
-  expect(isHandlerKind('request')([])).toBe(false)
-  expect(isHandlerKind('request')(123)).toBe(false)
-  expect(isHandlerKind('request')('hello')).toBe(false)
-})
-
-it('returns true if expected an event handler and given an event handler', () => {
-  expect(isHandlerKind('websocket')(new WebSocketHandler('*'))).toBe(true)
-})
-
-it('returns true if expected an event handler and given a custom event handler', () => {
-  class MyEventHandler extends WebSocketHandler {
-    constructor() {
-      super('*')
-    }
-  }
-  expect(isHandlerKind('websocket')(new MyEventHandler())).toBe(true)
-})
-
-it('returns false if expected an event handler but given arbitrary object', () => {
-  expect(isHandlerKind('websocket')(undefined)).toBe(false)
-  expect(isHandlerKind('websocket')(null)).toBe(false)
-  expect(isHandlerKind('websocket')({})).toBe(false)
-  expect(isHandlerKind('websocket')([])).toBe(false)
-  expect(isHandlerKind('websocket')(123)).toBe(false)
-  expect(isHandlerKind('websocket')('hello')).toBe(false)
-})

package/src/core/utils/internal/isHandlerKind.ts

@@ -1,17 +0,0 @@
-import type { AnyHandler } from '../../experimental/handlers-controller'
-import type { RequestHandler } from '../../handlers/RequestHandler'
-import type { WebSocketHandler } from '../../handlers/WebSocketHandler'
-import { isObject } from './isObject'
-
-/**
- * A filter function that ensures that the provided argument
- * is a handler of the given kind. This helps differentiate
- * between different kinds of handlers, e.g. request and event handlers.
- */
-export function isHandlerKind<K extends AnyHandler['kind']>(kind: K) {
-  return (
-    input: unknown,
-  ): input is K extends 'websocket' ? WebSocketHandler : RequestHandler => {
-    return isObject(input) && 'kind' in input && input.kind === kind
-  }
-}

package/src/core/utils/internal/isIterable.ts

@@ -1,32 +0,0 @@
-/**
- * This is the same as TypeScript's `Iterable`, but with all three type parameters.
- * @todo Remove once TypeScript 5.6 is the minimum.
- */
-export interface Iterable<T, TReturn, TNext> {
-  [Symbol.iterator](): Iterator<T, TReturn, TNext>
-}
-
-/**
- * This is the same as TypeScript's `AsyncIterable`, but with all three type parameters.
- * @todo Remove once TypeScript 5.6 is the minimum.
- */
-export interface AsyncIterable<T, TReturn, TNext> {
-  [Symbol.asyncIterator](): AsyncIterator<T, TReturn, TNext>
-}
-
-/**
- * Determines if the given function is an iterator.
- */
-export function isIterable<IteratorType>(
-  fn: any,
-): fn is
-  | Iterable<IteratorType, IteratorType, IteratorType>
-  | AsyncIterable<IteratorType, IteratorType, IteratorType> {
-  if (!fn) {
-    return false
-  }
-
-  return (
-    Reflect.has(fn, Symbol.iterator) || Reflect.has(fn, Symbol.asyncIterator)
-  )
-}

package/src/core/utils/internal/mergeRight.test.ts

@@ -1,43 +0,0 @@
-import { mergeRight } from './mergeRight'
-
-test('shallowly merges two given objects', () => {
-  expect(mergeRight({ a: 1, b: 2 }, { b: 3, c: 4 })).toEqual({
-    a: 1,
-    b: 3,
-    c: 4,
-  })
-})
-
-test('deeply merges two given objects', () => {
-  expect(
-    mergeRight(
-      {
-        a: 'string',
-        b: [1, 2],
-        c: {
-          d: 2,
-        },
-      },
-      {
-        a: 'another-string',
-        b: [3],
-        c: {
-          e: 'five',
-          f: {
-            g: true,
-          },
-        },
-      },
-    ),
-  ).toEqual({
-    a: 'another-string',
-    b: [1, 2, 3],
-    c: {
-      d: 2,
-      e: 'five',
-      f: {
-        g: true,
-      },
-    },
-  })
-})

package/src/core/utils/internal/mergeRight.ts

@@ -1,30 +0,0 @@
-import { isObject } from './isObject'
-
-/**
- * Deeply merges two given objects with the right one
- * having a priority during property assignment.
- */
-export function mergeRight(
-  left: Record<string, any>,
-  right: Record<string, any>,
-) {
-  return Object.entries(right).reduce(
-    (result, [key, rightValue]) => {
-      const leftValue = result[key]
-
-      if (Array.isArray(leftValue) && Array.isArray(rightValue)) {
-        result[key] = leftValue.concat(rightValue)
-        return result
-      }
-
-      if (isObject(leftValue) && isObject(rightValue)) {
-        result[key] = mergeRight(leftValue, rightValue)
-        return result
-      }
-
-      result[key] = rightValue
-      return result
-    },
-    Object.assign({}, left),
-  )
-}

package/src/core/utils/internal/pipeEvents.test.ts

@@ -1,14 +0,0 @@
-import { Emitter } from 'strict-event-emitter'
-import { pipeEvents } from './pipeEvents'
-
-it('pipes events from the source emitter to the destination emitter', () => {
-  const source = new Emitter()
-  const destination = new Emitter()
-  pipeEvents(source, destination)
-
-  const callback = vi.fn()
-  destination.on('hello', callback)
-
-  source.emit('hello', 'world', { data: true })
-  expect(callback).toHaveBeenNthCalledWith(1, 'world', { data: true })
-})

package/src/core/utils/internal/pipeEvents.ts

@@ -1,26 +0,0 @@
-import type { Emitter } from 'strict-event-emitter'
-import { type EventMap } from 'strict-event-emitter'
-
-/**
- * Pipes all emitted events from one emitter to another.
- */
-export function pipeEvents<Events extends EventMap>(
-  source: Emitter<Events>,
-  destination: Emitter<Events>,
-): void {
-  const rawEmit: typeof source.emit & { _isPiped?: boolean } = source.emit
-
-  if (rawEmit._isPiped) {
-    return
-  }
-
-  const sourceEmit: typeof source.emit & { _isPiped?: boolean } =
-    function sourceEmit(this: typeof source, event, ...data) {
-      destination.emit(event, ...data)
-      return rawEmit.call(this, event, ...data)
-    }
-
-  sourceEmit._isPiped = true
-
-  source.emit = sourceEmit
-}

package/src/core/utils/internal/tryCatch.test.ts

@@ -1,29 +0,0 @@
-import { tryCatch } from './tryCatch'
-
-test('returns the function payload', () => {
-  const result = tryCatch(() => 'hello')
-  expect(result).toEqual('hello')
-})
-
-test('silences exceptions by default', () => {
-  const result = tryCatch(() => {
-    throw new Error('Exception')
-  })
-
-  expect(result).toBeUndefined()
-})
-
-test('executes a custom callback function when an exception occurs', async () => {
-  await new Promise<void>((resolve) => {
-    tryCatch(
-      () => {
-        throw new Error('Exception')
-      },
-      (error) => {
-        expect(error).toBeInstanceOf(Error)
-        expect(error.message).toEqual('Exception')
-        resolve()
-      },
-    )
-  })
-})

package/src/core/utils/internal/tryCatch.ts

@@ -1,11 +0,0 @@
-export function tryCatch<Fn extends (...args: any[]) => any>(
-  fn: Fn,
-  onException?: (error: Error) => void,
-): ReturnType<Fn> | undefined {
-  try {
-    const result = fn()
-    return result
-  } catch (error) {
-    onException?.(error as Error)
-  }
-}

package/src/core/utils/matching/matchRequestUrl.test.ts

@@ -1,267 +0,0 @@
-// @vitest-environment jsdom
-import { coercePath, matchRequestUrl } from './matchRequestUrl'
-
-describe('matchRequestUrl', () => {
-  test('returns true when matches against an exact URL', () => {
-    expect(
-      matchRequestUrl(
-        new URL('https://test.mswjs.io'),
-        'https://test.mswjs.io',
-      ),
-    ).toEqual({
-      matches: true,
-      params: {},
-    })
-  })
-
-  test('returns true when matched against a wildcard', () => {
-    expect(matchRequestUrl(new URL('https://test.mswjs.io'), '*')).toEqual({
-      matches: true,
-      params: {
-        '0': 'https://test.mswjs.io/',
-      },
-    })
-  })
-
-  test('returns true when matched against a RegExp', () => {
-    expect(
-      matchRequestUrl(new URL('https://test.mswjs.io'), /test\.mswjs\.io/),
-    ).toEqual({
-      matches: true,
-      params: {},
-    })
-  })
-
-  test('returns path parameters when matched', () => {
-    expect(
-      matchRequestUrl(
-        new URL('https://test.mswjs.io/user/abc-123'),
-        'https://test.mswjs.io/user/:userId',
-      ),
-    ).toEqual({
-      matches: true,
-      params: {
-        userId: 'abc-123',
-      },
-    })
-  })
-
-  test('decodes path parameters', () => {
-    const url = 'http://example.com:5001/example'
-
-    expect(
-      matchRequestUrl(
-        new URL(`https://test.mswjs.io/reflect-url/${encodeURIComponent(url)}`),
-        'https://test.mswjs.io/reflect-url/:url',
-      ),
-    ).toEqual({
-      matches: true,
-      params: {
-        url,
-      },
-    })
-  })
-
-  test('returns false when does not match against the request URL', () => {
-    expect(
-      matchRequestUrl(new URL('https://test.mswjs.io'), 'https://google.com'),
-    ).toEqual({
-      matches: false,
-      params: {},
-    })
-  })
-
-  test('returns true when matching optional path parameters', () => {
-    expect(
-      matchRequestUrl(
-        new URL('https://test.mswjs.io/user/123'),
-        'https://test.mswjs.io/user/:userId?',
-      ),
-    ).toEqual({
-      matches: true,
-      params: {
-        userId: '123',
-      },
-    })
-  })
-
-  test('returns true when matching URLs with wildcard ports', () => {
-    expect
-      .soft(
-        matchRequestUrl(new URL('http://localhost:3000'), 'http://localhost:*'),
-      )
-      .toEqual({
-        matches: true,
-        params: {
-          '0': '3000/',
-        },
-      })
-
-    expect
-      .soft(
-        matchRequestUrl(
-          new URL('http://localhost:3000'),
-          'http://localhost:*/',
-        ),
-      )
-      .toEqual({
-        matches: true,
-        params: {
-          '0': '3000',
-        },
-      })
-  })
-
-  test('returns true when matching URLs with wildcard ports and pathnames', () => {
-    expect(
-      matchRequestUrl(
-        new URL('http://localhost:3000/resource'),
-        'http://localhost:*/resource',
-      ),
-    ).toEqual({
-      matches: true,
-      params: {
-        '0': '3000',
-      },
-    })
-  })
-
-  test('matches wildcard ports with other wildcard parameters', () => {
-    expect(
-      matchRequestUrl(
-        new URL('http://subdomain.localhost:3000/user/settings'),
-        'http://*.localhost:*/user/*',
-      ),
-    ).toEqual({
-      matches: true,
-      params: {
-        '0': 'subdomain',
-        '1': '3000',
-        '2': 'settings',
-      },
-    })
-  })
-
-  test('matches wildcard ports that also match a part of the pathname', () => {
-    expect(
-      matchRequestUrl(
-        new URL('http://localhost:3000/user/settings'),
-        'http://localhost:*/settings',
-      ),
-    ).toEqual({
-      matches: true,
-      params: {
-        '0': '3000/user',
-      },
-    })
-  })
-
-  test('returns true for matching WebSocket URL', () => {
-    expect(
-      matchRequestUrl(new URL('ws://test.mswjs.io'), 'ws://test.mswjs.io'),
-    ).toEqual({
-      matches: true,
-      params: {},
-    })
-    expect(
-      matchRequestUrl(new URL('wss://test.mswjs.io'), 'wss://test.mswjs.io'),
-    ).toEqual({
-      matches: true,
-      params: {},
-    })
-  })
-
-  test('returns false for non-matching WebSocket URL', () => {
-    expect(
-      matchRequestUrl(new URL('ws://test.mswjs.io'), 'ws://foo.mswjs.io'),
-    ).toEqual({
-      matches: false,
-      params: {},
-    })
-    expect(
-      matchRequestUrl(new URL('wss://test.mswjs.io'), 'wss://completely.diff'),
-    ).toEqual({
-      matches: false,
-      params: {},
-    })
-  })
-
-  test('returns path parameters when matched a WebSocket URL', () => {
-    expect(
-      matchRequestUrl(
-        new URL('wss://test.mswjs.io'),
-        'wss://:service.mswjs.io',
-      ),
-    ).toEqual({
-      matches: true,
-      params: {
-        service: 'test',
-      },
-    })
-  })
-
-  test('returns true for matching WebSocket URLs with wildcard ports', () => {
-    expect(
-      matchRequestUrl(new URL('ws://localhost:3000'), 'ws://localhost:*'),
-    ).toEqual({
-      matches: true,
-      params: {
-        '0': '3000/',
-      },
-    })
-  })
-})
-
-describe('coercePath', () => {
-  test('escapes the colon in protocol', () => {
-    expect(coercePath('https://example.com')).toEqual('https\\://example.com')
-    expect(coercePath('https://example.com/:userId')).toEqual(
-      'https\\://example.com/:userId',
-    )
-    expect(coercePath('http://localhost:3000')).toEqual(
-      'http\\://localhost\\:3000',
-    )
-  })
-
-  test('escapes the colon before the port number', () => {
-    expect(coercePath('localhost:8080')).toEqual('localhost\\:8080')
-    expect(coercePath('http://127.0.0.1:8080')).toEqual(
-      'http\\://127.0.0.1\\:8080',
-    )
-    expect(coercePath('https://example.com:1234')).toEqual(
-      'https\\://example.com\\:1234',
-    )
-
-    expect(coercePath('localhost:8080/:5678')).toEqual('localhost\\:8080/:5678')
-    expect(coercePath('https://example.com:8080/:5678')).toEqual(
-      'https\\://example.com\\:8080/:5678',
-    )
-    expect(coercePath('http://localhost:*')).toEqual(
-      'http\\://localhost\\:(.*)',
-    )
-    expect(coercePath('ws://localhost:*')).toEqual('ws\\://localhost\\:(.*)')
-  })
-
-  test('replaces wildcard with an unnnamed capturing group', () => {
-    expect(coercePath('*')).toEqual('(.*)')
-    expect(coercePath('**')).toEqual('(.*)')
-    expect(coercePath('/us*')).toEqual('/us(.*)')
-    expect(coercePath('/user/*')).toEqual('/user/(.*)')
-    expect(coercePath('https://example.com/user/*')).toEqual(
-      'https\\://example.com/user/(.*)',
-    )
-    expect(coercePath('https://example.com/us*')).toEqual(
-      'https\\://example.com/us(.*)',
-    )
-  })
-
-  test('preserves path parameter modifiers', () => {
-    expect(coercePath(':name*')).toEqual(':name*')
-    expect(coercePath('/foo/:name*')).toEqual('/foo/:name*')
-    expect(coercePath('/foo/**:name*')).toEqual('/foo/(.*):name*')
-    expect(coercePath('**/foo/*/:name*')).toEqual('(.*)/foo/(.*)/:name*')
-    expect(coercePath('/foo/:first/bar/:second*/*')).toEqual(
-      '/foo/:first/bar/:second*/(.*)',
-    )
-  })
-})

package/src/core/utils/matching/matchRequestUrl.ts

@@ -1,77 +0,0 @@
-import { match } from 'path-to-regexp'
-import { getCleanUrl } from '@mswjs/interceptors'
-import { normalizePath } from './normalizePath'
-
-export type Path = string | RegExp
-export type PathParams<KeyType extends keyof any = string> = {
-  [ParamName in KeyType]?: string | ReadonlyArray<string>
-}
-
-export interface Match {
-  matches: boolean
-  params?: PathParams
-}
-
-/**
- * Coerce a path supported by MSW into a path
- * supported by "path-to-regexp".
- */
-export function coercePath(path: string): string {
-  return (
-    path
-      /**
-       * Replace wildcards ("*") with unnamed capturing groups
-       * because "path-to-regexp" doesn't support wildcards.
-       * Ignore path parameter' modifiers (i.e. ":name*").
-       */
-      .replace(
-        /([:a-zA-Z_-]*)(\*{1,2})+/g,
-        (_, parameterName: string | undefined, wildcard: string) => {
-          const expression = '(.*)'
-
-          if (!parameterName) {
-            return expression
-          }
-
-          return parameterName.startsWith(':')
-            ? `${parameterName}${wildcard}`
-            : `${parameterName}${expression}`
-        },
-      )
-      /**
-       * Escape the port so that "path-to-regexp" can match
-       * absolute URLs with numeric or wildcard ports.
-       */
-      .replace(/([^/])(:)(?=(?:\d+|\(\.\*\))(?=\/|$))/, '$1\\$2')
-      /**
-       * Escape the protocol so that "path-to-regexp" could match
-       * absolute URL.
-       * @see https://github.com/pillarjs/path-to-regexp/issues/259
-       */
-      .replace(/^([^/]+)(:)(?=\/\/)/, '$1\\$2')
-  )
-}
-
-/**
- * Returns the result of matching given request URL against a mask.
- */
-export function matchRequestUrl(url: URL, path: Path, baseUrl?: string): Match {
-  const normalizedPath = normalizePath(path, baseUrl)
-  const cleanPath =
-    typeof normalizedPath === 'string'
-      ? coercePath(normalizedPath)
-      : normalizedPath
-
-  const cleanUrl = getCleanUrl(url)
-  const result = match(cleanPath, { decode: decodeURIComponent })(cleanUrl)
-  const params = (result && (result.params as PathParams)) || {}
-
-  return {
-    matches: result !== false,
-    params,
-  }
-}
-
-export function isPath(value: unknown): value is Path {
-  return typeof value === 'string' || value instanceof RegExp
-}