Compare text

Find the difference between two text files

Real-time editor
Hide whitespace changes
Hide unchanged lines
Disable line wrap
Layout
Diff precision
Text styles
Syntax highlighting

MSW diff between v0.36.8 and v1.3.5

Created Diff never expires
164 removals
261 lines
205 additions
303 lines
/* eslint-disable */
/* tslint:disable */
/* tslint:disable */


/**
/**
* Mock Service Worker (0.36.8).
* Mock Service Worker (1.3.5).
* @see https://github.com/mswjs/msw
* @see https://github.com/mswjs/msw
* - Please do NOT modify this file.
* - Please do NOT modify this file.
* - Please do NOT serve this file on production.
* - Please do NOT serve this file on production.
*/
*/


const INTEGRITY_CHECKSUM = '02f4ad4a2797f85668baf196e553d929'
const INTEGRITY_CHECKSUM = '3d6b9f06410d179a7f7404d4bf4c3c70'
const bypassHeaderName = 'x-msw-bypass'
const activeClientIds = new Set()
const activeClientIds = new Set()


self.addEventListener('install', function () {
self.addEventListener('install', function () {
return self.skipWaiting()
self.skipWaiting()
})
})


self.addEventListener('activate', async function (event) {
self.addEventListener('activate', function (event) {
return self.clients.claim()
event.waitUntil(self.clients.claim())
})
})


self.addEventListener('message', async function (event) {
self.addEventListener('message', async function (event) {
@@ -33,7 +32,9 @@ self.addEventListener('message', async function (event) {
const clientId = event.source.id

if (!clientId || !self.clients) {
return
return
}
}


const allClients = await self.clients.matchAll()
const client = await self.clients.get(clientId)

if (!client) {
return
}

const allClients = await self.clients.matchAll({
type: 'window',
})


switch (event.data) {
switch (event.data) {
case 'KEEPALIVE_REQUEST': {
case 'KEEPALIVE_REQUEST': {
@@ -83,30 +84,58 @@ self.addEventListener('message', async function (event) {
sendToClient(client, {
}
type: 'KEEPALIVE_RESPONSE',
Text moved to lines 168-181
})

// Resolve the "main" client for the given event.
// Client that issues a request doesn't necessarily equal the client
// that registered the worker. It's with the latter the worker should
// communicate with during the response resolving phase.
async function resolveMainClient(event) {
const client = await self.clients.get(event.clientId)

if (client.frameType === 'top-level') {
return client
}

const allClients = await self.clients.matchAll()
Text moved with changes to lines 184-199 (94.6% similarity)

return allClients
.filter((client) => {
// Get only those clients that are currently visible.
return client.visibilityState === 'visible'
})
.find((client) => {
// Find the client ID that's recorded in the
// set of clients that have registered the worker.
return activeClientIds.has(client.id)
})
}

async function handleRequest(event, requestId) {
const client = await resolveMainClient(event)
@@ -128,7 +157,7 @@ async function handleRequest(event, requestId) {
Text moved with changes to lines 157-162 (97.2% similarity)
statusText: clonedResponse.statusText,
body:
clonedResponse.body === null ? null : await clonedResponse.text(),
headers: serializeHeaders(clonedResponse.headers),
redirected: clonedResponse.redirected,
},
})
})
@@ -138,49 +167,78 @@ async function handleRequest(event, requestId) {
break
return response
}

async function getResponse(event, client, requestId) {
const { request } = event
const requestClone = request.clone()
const getOriginalResponse = () => fetch(requestClone)
Text moved to lines 214-230

// Bypass mocking when the request client is not active.
if (!client) {
return getOriginalResponse()
}

// Bypass initial page load requests (i.e. static assets).
// The absence of the immediate/parent client in the map of the active clients
// means that MSW hasn't dispatched the "MOCK_ACTIVATE" event yet
// and is not ready to handle requests.
if (!activeClientIds.has(client.id)) {
return await getOriginalResponse()
}

// Bypass requests with the explicit bypass header
if (requestClone.headers.get(bypassHeaderName) === 'true') {
const cleanRequestHeaders = serializeHeaders(requestClone.headers)

// Remove the bypass header to comply with the CORS preflight check.
delete cleanRequestHeaders[bypassHeaderName]

const originalRequest = new Request(requestClone, {
headers: new Headers(cleanRequestHeaders),
})

return fetch(originalRequest)
}

// Send the request to the client-side MSW.
const reqHeaders = serializeHeaders(request.headers)
const body = await request.text()

Text moved to lines 235-240
const clientMessage = await sendToClient(client, {
type: 'REQUEST',
payload: {
id: requestId,
url: request.url,
method: request.method,
headers: reqHeaders,
Text moved to lines 242-244
cache: request.cache,
mode: request.mode,
credentials: request.credentials,
@@ -189,115 +247,32 @@ async function getResponse(event, client, requestId) {
Text moved to lines 247-249
redirect: request.redirect,
referrer: request.referrer,
referrerPolicy: request.referrerPolicy,
body,
Text moved with changes to lines 251-258 (93.9% similarity)
bodyUsed: request.bodyUsed,
keepalive: request.keepalive,
},
})

switch (clientMessage.type) {
case 'MOCK_SUCCESS': {
return delayPromise(
() => respondWithMock(clientMessage),
clientMessage.payload.delay,
)
}
}


case 'MOCK_NOT_FOUND': {
case 'INTEGRITY_CHECK_REQUEST': {
return getOriginalResponse()
sendToClient(client, {
type: 'INTEGRITY_CHECK_RESPONSE',
payload: INTEGRITY_CHECKSUM,
})
break
}
}


case 'NETWORK_ERROR': {
case 'MOCK_ACTIVATE': {
const { name, message } = clientMessage.payload
activeClientIds.add(clientId)
const networkError = new Error(message)
networkError.name = name


// Rejecting a request Promise emulates a network error.
sendToClient(client, {
throw networkError
type: 'MOCKING_ENABLED',
payload: true,
})
break
}
}


case 'INTERNAL_ERROR': {
case 'MOCK_DEACTIVATE': {
const parsedBody = JSON.parse(clientMessage.payload.body)
activeClientIds.delete(clientId)
break
}


console.error(
case 'CLIENT_CLOSED': {
`\
activeClientIds.delete(clientId)
[MSW] Uncaught exception in the request handler for "%s %s":
${parsedBody.location}
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/recipes/mocking-error-responses\
`,
request.method,
request.url,
)


return respondWithMock(clientMessage)
const remainingClients = allClients.filter((client) => {
return client.id !== clientId
})

// Unregister itself when there are no more clients
if (remainingClients.length === 0) {
self.registration.unregister()
}

break
}
}
}
}

})
return getOriginalResponse()
}


self.addEventListener('fetch', function (event) {
self.addEventListener('fetch', function (event) {
const { request } = event
const { request } = event
const accept = request.headers.get('accept') || ''
const accept = request.headers.get('accept') || ''


// Bypass server-sent events.
// Bypass server-sent events.
if (accept.includes('text/event-stream')) {
if (accept.includes('text/event-stream')) {
return
return
}
}


// Bypass navigation requests.
// Bypass navigation requests.
if (request.mode === 'navigate') {
if (request.mode === 'navigate') {
return
return
}
}


// Opening the DevTools triggers the "only-if-cached" request
// Opening the DevTools triggers the "only-if-cached" request
// that cannot be handled by the worker. Bypass such requests.
// that cannot be handled by the worker. Bypass such requests.
if (request.cache === 'only-if-cached' && request.mode !== 'same-origin') {
if (request.cache === 'only-if-cached' && request.mode !== 'same-origin') {
return
return
}
}


// Bypass all requests when there are no active clients.
// Bypass all requests when there are no active clients.
// Prevents the self-unregistered worked from handling requests
// Prevents the self-unregistered worked from handling requests
// after it's been deleted (still remains active until the next reload).
// after it's been deleted (still remains active until the next reload).
if (activeClientIds.size === 0) {
if (activeClientIds.size === 0) {
return
return
}
}


const requestId = uuidv4()
// Generate unique request ID.
const requestId = Math.random().toString(16).slice(2)


return event.respondWith(
event.respondWith(
handleRequest(event, requestId).catch((error) => {
handleRequest(event, requestId).catch((error) => {
if (error.name === 'NetworkError') {
if (error.name === 'NetworkError') {
console.warn(
console.warn(
'[MSW] Successfully emulated a network error for the "%s %s" request.',
'[MSW] Successfully emulated a network error for the "%s %s" request.',
request.method,
request.method,
request.url,
request.url,
)
)
return
return
}
}


// At this point, any exception indicates an issue with the original request/response.
// At this point, any exception indicates an issue with the original request/response.
console.error(
console.error(
`\
`\
[MSW] Caught an exception from the "%s %s" request (%s). This is probably not a problem with Mock Service Worker. There is likely an additional logging output above.`,
[MSW] Caught an exception from the "%s %s" request (%s). This is probably not a problem with Mock Service Worker. There is likely an additional logging output above.`,
request.method,
request.method,
request.url,
request.url,
`${error.name}: ${error.message}`,
`${error.name}: ${error.message}`,
)
)
}),
}),
)
)
})
})


function serializeHeaders(headers) {
async function handleRequest(event, requestId) {
const reqHeaders = {}
const client = await resolveMainClient(event)
headers.forEach((value, name) => {
const response = await getResponse(event, client, requestId)
reqHeaders[name] = reqHeaders[name]

? [].concat(reqHeaders[name]).concat(value)
// Send back the response clone for the "response:*" life-cycle events.
: value
// Ensure MSW is active and ready to handle the message, otherwise
// this message will pend indefinitely.
if (client && activeClientIds.has(client.id)) {
;(async function () {
const clonedResponse = response.clone()
sendToClient(client, {
type: 'RESPONSE',
payload: {
requestId,
type: clonedResponse.type,
ok: clonedResponse.ok,
status: clonedResponse.status,
Text moved with changes from lines 63-68 (97.2% similarity)
statusText: clonedResponse.statusText,
body:
clonedResponse.body === null ? null : await clonedResponse.text(),
headers: Object.fromEntries(clonedResponse.headers.entries()),
redirected: clonedResponse.redirected,
},
})
})()
}

return response
Text moved from lines 33-46
}

// Resolve the main client for the given event.
// Client that issues a request doesn't necessarily equal the client
// that registered the worker. It's with the latter the worker should
// communicate with during the response resolving phase.
async function resolveMainClient(event) {
const client = await self.clients.get(event.clientId)

if (client?.frameType === 'top-level') {
return client
}

const allClients = await self.clients.matchAll({
type: 'window',
})
})
Text moved with changes from lines 47-62 (94.6% similarity)
return reqHeaders

return allClients
.filter((client) => {
// Get only those clients that are currently visible.
return client.visibilityState === 'visible'
})
.find((client) => {
// Find the client ID that's recorded in the
// set of clients that have registered the worker.
return activeClientIds.has(client.id)
})
}

async function getResponse(event, client, requestId) {
const { request } = event
const clonedRequest = request.clone()

function passthrough() {
// Clone the request because it might've been already used
// (i.e. its body has been read and sent to the client).
const headers = Object.fromEntries(clonedRequest.headers.entries())

// Remove MSW-specific request headers so the bypassed requests
// comply with the server's CORS preflight check.
// Operate with the headers as an object because request "Headers"
// are immutable.
delete headers['x-msw-bypass']

return fetch(clonedRequest, { headers })
}
Text moved from lines 78-94

// Bypass mocking when the client is not active.
if (!client) {
return passthrough()
}

// Bypass initial page load requests (i.e. static assets).
// The absence of the immediate/parent client in the map of the active clients
// means that MSW hasn't dispatched the "MOCK_ACTIVATE" event yet
// and is not ready to handle requests.
if (!activeClientIds.has(client.id)) {
return passthrough()
}

// Bypass requests with the explicit bypass header.
// Such requests can be issued by "ctx.fetch()".
if (request.headers.get('x-msw-bypass') === 'true') {
return passthrough()
}

// Notify the client that a request has been intercepted.
Text moved from lines 110-115
const clientMessage = await sendToClient(client, {
type: 'REQUEST',
payload: {
id: requestId,
url: request.url,
method: request.method,
headers: Object.fromEntries(request.headers.entries()),
Text moved from lines 117-119
cache: request.cache,
mode: request.mode,
credentials: request.credentials,
destination: request.destination,
integrity: request.integrity,
Text moved from lines 121-123
redirect: request.redirect,
referrer: request.referrer,
referrerPolicy: request.referrerPolicy,
body: await request.text(),
Text moved with changes from lines 125-132 (93.9% similarity)
bodyUsed: request.bodyUsed,
keepalive: request.keepalive,
},
})

switch (clientMessage.type) {
case 'MOCK_RESPONSE': {
return respondWithMock(clientMessage.data)
}

case 'MOCK_NOT_FOUND': {
return passthrough()
}

case 'NETWORK_ERROR': {
const { name, message } = clientMessage.data
const networkError = new Error(message)
networkError.name = name

// Rejecting a "respondWith" promise emulates a network error.
throw networkError
}
}

return passthrough()
}
}


function sendToClient(client, message) {
function sendToClient(client, message) {
@@ -312,27 +287,17 @@ function sendToClient(client, message) {
return new Promise((resolve, reject) => {
const channel = new MessageChannel()

channel.port1.onmessage = (event) => {
if (event.data && event.data.error) {
return reject(event.data.error)
}

resolve(event.data)
resolve(event.data)
}
}


client.postMessage(JSON.stringify(message), [channel.port2])
client.postMessage(message, [channel.port2])
})
})
}
}


function delayPromise(cb, duration) {
function sleep(timeMs) {
return new Promise((resolve) => {
return new Promise((resolve) => {
setTimeout(() => resolve(cb()), duration)
setTimeout(resolve, timeMs)
})
}

function respondWithMock(clientMessage) {
return new Response(clientMessage.payload.body, {
...clientMessage.payload,
headers: clientMessage.payload.headers,
})
})
}
}


function uuidv4() {
async function respondWithMock(response) {
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
await sleep(response.delay)
const r = (Math.random() * 16) | 0
return new Response(response.body, response)
const v = c == 'x' ? r : (r & 0x3) | 0x8
return v.toString(16)
})
}
}
Saved diffs