msw 2.1.3 → 2.1.5

package/lib/mockServiceWorker.js

@@ -2,7 +2,7 @@
 /* tslint:disable */
 
 /**
- * Mock Service Worker (2.1.3).
+ * Mock Service Worker (2.1.5).
  * @see https://github.com/mswjs/msw
  * - Please do NOT modify this file.
  * - Please do NOT serve this file on production.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msw",
-  "version": "2.1.3",
+  "version": "2.1.5",
   "description": "Seamless REST/GraphQL API mocking library for browser and Node.js.",
   "main": "./lib/core/index.js",
   "module": "./lib/core/index.mjs",
@@ -93,13 +93,11 @@
   "sideEffects": false,
   "dependencies": {
     "@bundled-es-modules/cookie": "^2.0.0",
-    "@bundled-es-modules/js-levenshtein": "^2.0.1",
     "@bundled-es-modules/statuses": "^1.0.1",
     "@mswjs/cookies": "^1.1.0",
-    "@mswjs/interceptors": "^0.25.14",
+    "@mswjs/interceptors": "^0.25.15",
     "@open-draft/until": "^2.1.0",
     "@types/cookie": "^0.6.0",
-    "@types/js-levenshtein": "^1.1.3",
     "@types/statuses": "^2.0.4",
     "chalk": "^4.1.2",
     "chokidar": "^3.4.2",
@@ -107,7 +105,6 @@
     "headers-polyfill": "^4.0.2",
     "inquirer": "^8.2.0",
     "is-node-process": "^1.2.0",
-    "js-levenshtein": "^1.1.6",
     "outvariant": "^1.4.2",
     "path-to-regexp": "^6.2.0",
     "strict-event-emitter": "^0.5.1",
@@ -192,10 +189,10 @@
     "check:exports": "node \"./config/scripts/validate-esm.js\"",
     "test": "pnpm test:unit && pnpm test:node && pnpm test:browser && pnpm test:native",
     "test:unit": "vitest",
-    "test:node": "vitest run --config=./test/node/vitest.config.ts",
-    "test:native": "vitest run --config=./test/native/vitest.config.ts",
+    "test:node": "vitest --config=./test/node/vitest.config.ts",
+    "test:native": "vitest --config=./test/native/vitest.config.ts",
     "test:browser": "playwright test -c ./test/browser/playwright.config.ts",
-    "test:modules:node": "vitest run --config=./test/modules/node/vitest.config.ts",
+    "test:modules:node": "vitest --config=./test/modules/node/vitest.config.ts",
     "test:modules:browser": "playwright test -c ./test/modules/browser/playwright.config.ts",
     "test:ts": "ts-node test/typings/run.ts",
     "release": "release publish",

package/src/browser/setupWorker/glossary.ts

@@ -103,6 +103,7 @@ export interface SetupWorkerInternalContext {
   worker: ServiceWorker | null
   registration: ServiceWorkerRegistration | null
   requestHandlers: Array<RequestHandler>
+  requests: Map<string, Request>
   emitter: Emitter<LifeCycleEventsMap>
   keepAliveInterval?: number
   workerChannel: {

package/src/browser/setupWorker/setupWorker.ts

@@ -60,6 +60,7 @@ export class SetupWorkerApi
       worker: null,
       registration: null,
       requestHandlers: this.currentHandlers,
+      requests: new Map(),
       emitter: this.emitter,
       workerChannel: {
         on: (eventType, callback) => {

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

@@ -8,6 +8,7 @@ import {
   WorkerChannel,
 } from './utils/createMessageChannel'
 import { parseWorkerRequest } from '../../utils/parseWorkerRequest'
+import { RequestHandler } from '~/core/handlers/RequestHandler'
 import { handleRequest } from '~/core/utils/handleRequest'
 import { RequiredDeep } from '~/core/typeUtils'
 import { devUtils } from '~/core/utils/internal/devUtils'
@@ -30,6 +31,14 @@ export const createRequestListener = (
     const request = parseWorkerRequest(message.payload)
     const requestCloneForLogs = request.clone()
 
+    // Make this the first requets 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)
+    context.requests.set(requestId, requestClone)
+
     try {
       await handleRequest(
         request,

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

@@ -1,8 +1,8 @@
-import {
+import type {
   ServiceWorkerIncomingEventsMap,
   SetupWorkerInternalContext,
 } from '../glossary'
-import { ServiceWorkerMessage } from './utils/createMessageChannel'
+import type { ServiceWorkerMessage } from './utils/createMessageChannel'
 import { isResponseWithoutBody } from '@mswjs/interceptors'
 
 export function createResponseListener(context: SetupWorkerInternalContext) {
@@ -15,6 +15,12 @@ export function createResponseListener(context: SetupWorkerInternalContext) {
   ) => {
     const { payload: responseJson } = message
 
+    // Get the Request instance reference stored in the
+    // request listener.
+    const { requestId } = responseJson
+    const request = context.requests.get(requestId)!
+    context.requests.delete(requestId)
+
     /**
      * CORS requests with `mode: "no-cors"` result in "opaque" responses.
      * That kind of responses cannot be manipulated in JavaScript due
@@ -46,11 +52,7 @@ export function createResponseListener(context: SetupWorkerInternalContext) {
       responseJson.isMockedResponse ? 'response:mocked' : 'response:bypass',
       {
         response,
-        /**
-         * @todo @fixme In this context, we don't know anything about
-         * the request.
-         */
-        request: null as any,
+        request,
         requestId: responseJson.requestId,
       },
     )

package/src/core/handlers/GraphQLHandler.ts

@@ -17,7 +17,7 @@ import {
   parseGraphQLRequest,
   parseDocumentNode,
 } from '../utils/internal/parseGraphQLRequest'
-import { getPublicUrlFromRequest } from '../utils/request/getPublicUrlFromRequest'
+import { toPublicUrl } from '../utils/request/toPublicUrl'
 import { devUtils } from '../utils/internal/devUtils'
 import { getAllRequestCookies } from '../utils/request/getRequestCookies'
 
@@ -200,7 +200,7 @@ export class GraphQLHandler extends RequestHandler<
     }
 
     if (!args.parsedResult.operationName && this.info.operationType !== 'all') {
-      const publicUrl = getPublicUrlFromRequest(args.request)
+      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.

package/src/core/handlers/HttpHandler.ts

@@ -11,7 +11,7 @@ import {
   Path,
   PathParams,
 } from '../utils/matching/matchRequestUrl'
-import { getPublicUrlFromRequest } from '../utils/request/getPublicUrlFromRequest'
+import { toPublicUrl } from '../utils/request/toPublicUrl'
 import { getAllRequestCookies } from '../utils/request/getRequestCookies'
 import { cleanUrl, getSearchParams } from '../utils/url/cleanUrl'
 import {
@@ -147,7 +147,7 @@ export class HttpHandler extends RequestHandler<
   }
 
   async log(args: { request: Request; response: Response }) {
-    const publicUrl = getPublicUrlFromRequest(args.request)
+    const publicUrl = toPublicUrl(args.request.url)
     const loggedRequest = await serializeRequest(args.request)
     const loggedResponse = await serializeResponse(args.response)
     const statusColor = getStatusCodeColor(loggedResponse.status)

package/src/core/utils/handleRequest.ts

@@ -82,7 +82,7 @@ export async function handleRequest(
   // If the handler lookup returned nothing, no request handler was found
   // matching this request. Report the request as unhandled.
   if (!lookupResult.data) {
-    await onUnhandledRequest(request, handlers, options.onUnhandledRequest)
+    await onUnhandledRequest(request, options.onUnhandledRequest)
     emitter.emit('request:unhandled', { request, requestId })
     emitter.emit('request:end', { request, requestId })
     handleRequestOptions?.onPassthroughResponse?.(request)

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

@@ -5,7 +5,7 @@ import type {
 } from 'graphql'
 import { parse } from 'graphql'
 import type { GraphQLVariables } from '../../handlers/GraphQLHandler'
-import { getPublicUrlFromRequest } from '../request/getPublicUrlFromRequest'
+import { toPublicUrl } from '../request/toPublicUrl'
 import { devUtils } from './devUtils'
 import { jsonParse } from './jsonParse'
 import { parseMultipartData } from './parseMultipartData'
@@ -184,7 +184,7 @@ export async function parseGraphQLRequest(
   const parsedResult = parseQuery(query)
 
   if (parsedResult instanceof Error) {
-    const requestPublicUrl = getPublicUrlFromRequest(request)
+    const requestPublicUrl = toPublicUrl(request.url)
 
     throw new Error(
       devUtils.formatMessage(

package/src/core/utils/request/onUnhandledRequest.test.ts

@@ -5,10 +5,6 @@ import {
   onUnhandledRequest,
   UnhandledRequestCallback,
 } from './onUnhandledRequest'
-import { HttpHandler, HttpMethods } from '../../handlers/HttpHandler'
-import { ResponseResolver } from '../../handlers/RequestHandler'
-
-const resolver: ResponseResolver = () => void 0
 
 const fixtures = {
   warningWithoutSuggestions: `\
@@ -24,18 +20,6 @@ Read more: https://mswjs.io/docs/getting-started/mocks`,
 
   • GET /api
 
-If you still wish to intercept this unhandled request, please create a request handler for it.
-Read more: https://mswjs.io/docs/getting-started/mocks`,
-
-  warningWithSuggestions: (suggestions: string) => `\
-[MSW] Warning: intercepted a request without a matching request handler:
-
-  • GET /api
-
-Did you mean to request one of the following resources instead?
-
-${suggestions}
-
 If you still wish to intercept this unhandled request, please create a request handler for it.
 Read more: https://mswjs.io/docs/getting-started/mocks`,
 }
@@ -52,7 +36,6 @@ afterEach(() => {
 test('supports the "bypass" request strategy', async () => {
   await onUnhandledRequest(
     new Request(new URL('http://localhost/api')),
-    [],
     'bypass',
   )
 
@@ -61,22 +44,14 @@ test('supports the "bypass" request strategy', async () => {
 })
 
 test('supports the "warn" request strategy', async () => {
-  await onUnhandledRequest(
-    new Request(new URL('http://localhost/api')),
-    [],
-    'warn',
-  )
+  await onUnhandledRequest(new Request(new URL('http://localhost/api')), 'warn')
 
   expect(console.warn).toHaveBeenCalledWith(fixtures.warningWithoutSuggestions)
 })
 
 test('supports the "error" request strategy', async () => {
   await expect(
-    onUnhandledRequest(
-      new Request(new URL('http://localhost/api')),
-      [],
-      'error',
-    ),
+    onUnhandledRequest(new Request(new URL('http://localhost/api')), 'error'),
   ).rejects.toThrow(
     '[MSW] Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.',
   )
@@ -89,7 +64,7 @@ test('supports a custom callback function', async () => {
     console.warn(`callback: ${request.method} ${request.url}`)
   })
   const request = new Request(new URL('/user', 'http://localhost:3000'))
-  await onUnhandledRequest(request, [], callback)
+  await onUnhandledRequest(request, callback)
 
   expect(callback).toHaveBeenCalledTimes(1)
   expect(callback).toHaveBeenCalledWith(request, {
@@ -111,7 +86,7 @@ test('supports calling default strategies from the custom callback function', as
     },
   )
   const request = new Request(new URL('http://localhost/api'))
-  await expect(onUnhandledRequest(request, [], callback)).rejects.toThrow(
+  await expect(onUnhandledRequest(request, callback)).rejects.toThrow(
     `[MSW] Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.`,
   )
 
@@ -126,86 +101,15 @@ test('supports calling default strategies from the custom callback function', as
 })
 
 test('does not print any suggestions given no handlers to suggest', async () => {
-  await onUnhandledRequest(
-    new Request(new URL('http://localhost/api')),
-    [],
-    'warn',
-  )
-
-  expect(console.warn).toHaveBeenCalledWith(fixtures.warningWithoutSuggestions)
-})
-
-test('does not print any suggestions given no handlers are similar', async () => {
-  await onUnhandledRequest(
-    new Request(new URL('http://localhost/api')),
-    [
-      // None of the defined request handlers match the actual request URL
-      // to be used as suggestions.
-      new HttpHandler(HttpMethods.GET, 'https://api.github.com', resolver),
-      new HttpHandler(HttpMethods.GET, 'https://api.stripe.com', resolver),
-    ],
-    'warn',
-  )
+  await onUnhandledRequest(new Request(new URL('http://localhost/api')), 'warn')
 
   expect(console.warn).toHaveBeenCalledWith(fixtures.warningWithoutSuggestions)
 })
 
-test('respects RegExp as a request handler method', async () => {
-  await onUnhandledRequest(
-    new Request(new URL('http://localhost/api')),
-    [new HttpHandler(/^GE/, 'http://localhost/api', resolver)],
-    'warn',
-  )
-
-  expect(console.warn).toHaveBeenCalledWith(fixtures.warningWithoutSuggestions)
-})
-
-test('sorts the suggestions by relevance', async () => {
-  await onUnhandledRequest(
-    new Request(new URL('http://localhost/api')),
-    [
-      new HttpHandler(HttpMethods.GET, '/', resolver),
-      new HttpHandler(HttpMethods.GET, 'https://api.example.com/api', resolver),
-      new HttpHandler(HttpMethods.POST, '/api', resolver),
-    ],
-    'warn',
-  )
-
-  expect(console.warn).toHaveBeenCalledWith(
-    fixtures.warningWithSuggestions(`\
-  • POST /api
-  • GET /`),
-  )
-})
-
-test('does not print more than 4 suggestions', async () => {
-  await onUnhandledRequest(
-    new Request(new URL('http://localhost/api')),
-    [
-      new HttpHandler(HttpMethods.GET, '/ap', resolver),
-      new HttpHandler(HttpMethods.GET, '/api', resolver),
-      new HttpHandler(HttpMethods.GET, '/api-1', resolver),
-      new HttpHandler(HttpMethods.GET, '/api-2', resolver),
-      new HttpHandler(HttpMethods.GET, '/api-3', resolver),
-      new HttpHandler(HttpMethods.GET, '/api-4', resolver),
-    ],
-    'warn',
-  )
-
-  expect(console.warn).toHaveBeenCalledWith(
-    fixtures.warningWithSuggestions(`\
-  • GET /api
-  • GET /ap
-  • GET /api-1
-  • GET /api-2`),
-  )
-})
-
 test('throws an exception given unknown request strategy', async () => {
   await expect(
     onUnhandledRequest(
       new Request(new URL('http://localhost/api')),
-      [],
       // @ts-expect-error Intentional unknown strategy.
       'invalid-strategy',
     ),

package/src/core/utils/request/onUnhandledRequest.ts

@@ -1,22 +1,6 @@
-import jsLevenshtein from '@bundled-es-modules/js-levenshtein'
-import { RequestHandler } from '../../handlers/RequestHandler'
-import { HttpHandler } from '../../handlers/HttpHandler'
-import { GraphQLHandler } from '../../handlers/GraphQLHandler'
-import {
-  ParsedGraphQLQuery,
-  ParsedGraphQLRequest,
-  parseGraphQLRequest,
-} from '../internal/parseGraphQLRequest'
-import { getPublicUrlFromRequest } from './getPublicUrlFromRequest'
-import { isStringEqual } from '../internal/isStringEqual'
+import { toPublicUrl } from './toPublicUrl'
 import { devUtils } from '../internal/devUtils'
 
-const getStringMatchScore = jsLevenshtein
-
-const MAX_MATCH_SCORE = 3
-const MAX_SUGGESTION_COUNT = 4
-const TYPE_MATCH_DELTA = 0.5
-
 export interface UnhandledRequestPrint {
   warning(): void
   error(): void
@@ -33,183 +17,20 @@ export type UnhandledRequestStrategy =
   | 'error'
   | UnhandledRequestCallback
 
-interface RequestHandlerGroups {
-  http: Array<HttpHandler>
-  graphql: Array<GraphQLHandler>
-}
-
-function groupHandlersByType(
-  handlers: Array<RequestHandler>,
-): RequestHandlerGroups {
-  return handlers.reduce<RequestHandlerGroups>(
-    (groups, handler) => {
-      if (handler instanceof HttpHandler) {
-        groups.http.push(handler)
-      }
-
-      if (handler instanceof GraphQLHandler) {
-        groups.graphql.push(handler)
-      }
-
-      return groups
-    },
-    {
-      http: [],
-      graphql: [],
-    },
-  )
-}
-
-type RequestHandlerSuggestion = [number, RequestHandler]
-
-type ScoreGetterFn<RequestHandlerType extends RequestHandler> = (
-  request: Request,
-  handler: RequestHandlerType,
-) => number
-
-function getHttpHandlerScore(): ScoreGetterFn<HttpHandler> {
-  return (request, handler) => {
-    const { path, method } = handler.info
-
-    if (path instanceof RegExp || method instanceof RegExp) {
-      return Infinity
-    }
-
-    const hasSameMethod = isStringEqual(request.method, method)
-
-    // Always treat a handler with the same method as a more similar one.
-    const methodScoreDelta = hasSameMethod ? TYPE_MATCH_DELTA : 0
-    const requestPublicUrl = getPublicUrlFromRequest(request)
-    const score = getStringMatchScore(requestPublicUrl, path)
-
-    return score - methodScoreDelta
-  }
-}
-
-function getGraphQLHandlerScore(
-  parsedQuery: ParsedGraphQLQuery,
-): ScoreGetterFn<GraphQLHandler> {
-  return (_, handler) => {
-    if (typeof parsedQuery.operationName === 'undefined') {
-      return Infinity
-    }
-
-    const { operationType, operationName } = handler.info
-
-    if (typeof operationName !== 'string') {
-      return Infinity
-    }
-
-    const hasSameOperationType = parsedQuery.operationType === operationType
-    // Always treat a handler with the same operation type as a more similar one.
-    const operationTypeScoreDelta = hasSameOperationType ? TYPE_MATCH_DELTA : 0
-    const score = getStringMatchScore(parsedQuery.operationName, operationName)
-
-    return score - operationTypeScoreDelta
-  }
-}
-
-function getSuggestedHandler(
-  request: Request,
-  handlers: Array<HttpHandler> | Array<GraphQLHandler>,
-  getScore: ScoreGetterFn<HttpHandler> | ScoreGetterFn<GraphQLHandler>,
-): Array<RequestHandler> {
-  const suggestedHandlers = (handlers as Array<RequestHandler>)
-    .reduce<Array<RequestHandlerSuggestion>>((suggestions, handler) => {
-      const score = getScore(request, handler as any)
-      return suggestions.concat([[score, handler]])
-    }, [])
-    .sort(([leftScore], [rightScore]) => leftScore - rightScore)
-    .filter(([score]) => score <= MAX_MATCH_SCORE)
-    .slice(0, MAX_SUGGESTION_COUNT)
-    .map(([, handler]) => handler)
-
-  return suggestedHandlers
-}
-
-function getSuggestedHandlersMessage(handlers: RequestHandler[]) {
-  if (handlers.length > 1) {
-    return `\
-Did you mean to request one of the following resources instead?
-
-${handlers.map((handler) => `  • ${handler.info.header}`).join('\n')}`
-  }
-
-  return `Did you mean to request "${handlers[0].info.header}" instead?`
-}
-
 export async function onUnhandledRequest(
   request: Request,
-  handlers: Array<RequestHandler>,
   strategy: UnhandledRequestStrategy = 'warn',
 ): Promise<void> {
-  const parsedGraphQLQuery = await parseGraphQLRequest(request).catch(
-    () => null,
-  )
-  const publicUrl = getPublicUrlFromRequest(request)
-
-  function generateHandlerSuggestion(): string {
-    /**
-     * @note Ignore exceptions during GraphQL request parsing because at this point
-     * we cannot assume the unhandled request is a valid GraphQL request.
-     * If the GraphQL parsing fails, just don't treat it as a GraphQL request.
-     */
-    const handlerGroups = groupHandlersByType(handlers)
-    const relevantHandlers = parsedGraphQLQuery
-      ? handlerGroups.graphql
-      : handlerGroups.http
+  const url = new URL(request.url)
+  const publicUrl = toPublicUrl(url)
 
-    const suggestedHandlers = getSuggestedHandler(
-      request,
-      relevantHandlers,
-      parsedGraphQLQuery
-        ? getGraphQLHandlerScore(parsedGraphQLQuery)
-        : getHttpHandlerScore(),
-    )
-
-    return suggestedHandlers.length > 0
-      ? getSuggestedHandlersMessage(suggestedHandlers)
-      : ''
-  }
-
-  function getGraphQLRequestHeader(
-    parsedGraphQLRequest: ParsedGraphQLRequest<any>,
-  ): string {
-    if (!parsedGraphQLRequest?.operationName) {
-      return `anonymous ${parsedGraphQLRequest?.operationType} (${request.method} ${publicUrl})`
-    }
-
-    return `${parsedGraphQLRequest.operationType} ${parsedGraphQLRequest.operationName} (${request.method} ${publicUrl})`
-  }
-
-  function generateUnhandledRequestMessage(): string {
-    const requestHeader = parsedGraphQLQuery
-      ? getGraphQLRequestHeader(parsedGraphQLQuery)
-      : `${request.method} ${publicUrl}`
-    const handlerSuggestion = generateHandlerSuggestion()
-
-    const messageTemplate = [
-      `intercepted a request without a matching request handler:`,
-      `  \u2022 ${requestHeader}`,
-      handlerSuggestion,
-      `\
-If you still wish to intercept this unhandled request, please create a request handler for it.
-Read more: https://mswjs.io/docs/getting-started/mocks\
-`,
-    ].filter(Boolean)
-    return messageTemplate.join('\n\n')
-  }
+  const unhandledRequestMessage = `intercepted a request without a matching request handler:\n\n  \u2022 ${request.method} ${publicUrl}\n\nIf you still wish to intercept this unhandled request, please create a request handler for it.\nRead more: https://mswjs.io/docs/getting-started/mocks`
 
   function applyStrategy(strategy: UnhandledRequestStrategy) {
-    // Generate handler suggestions only when applying the strategy.
-    // This saves bandwidth for scenarios when developers opt-out
-    // from the default unhandled request handling strategy.
-    const message = generateUnhandledRequestMessage()
-
     switch (strategy) {
       case 'error': {
         // Print a developer-friendly error.
-        devUtils.error('Error: %s', message)
+        devUtils.error('Error: %s', unhandledRequestMessage)
 
         // Throw an exception to halt request processing and not perform the original request.
         throw new Error(
@@ -220,7 +41,7 @@ Read more: https://mswjs.io/docs/getting-started/mocks\
       }
 
       case 'warn': {
-        devUtils.warn('Warning: %s', message)
+        devUtils.warn('Warning: %s', unhandledRequestMessage)
         break
       }
 
@@ -245,5 +66,15 @@ Read more: https://mswjs.io/docs/getting-started/mocks\
     return
   }
 
+  /**
+   * @note Ignore "file://" requests.
+   * Those often are an implementation detail of modern tooling
+   * that fetches modules via HTTP. Developers don't issue those
+   * requests and so they mustn't be warned about them.
+   */
+  if (url.protocol === 'file:') {
+    return
+  }
+
   applyStrategy(strategy)
 }

package/src/core/utils/request/toPublicUrl.test.ts

@@ -0,0 +1,18 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { toPublicUrl } from './toPublicUrl'
+
+test('returns an absolute request URL withouth search params', () => {
+  expect(toPublicUrl(new URL('https://test.mswjs.io/path'))).toBe(
+    'https://test.mswjs.io/path',
+  )
+
+  expect(toPublicUrl(new URL('http://localhost/path'))).toBe('/path')
+
+  expect(toPublicUrl(new URL('http://localhost/path?foo=bar'))).toBe('/path')
+})
+
+it('returns a relative URL given the request to the same origin', () => {
+  expect(toPublicUrl('http://localhost/user')).toBe('/user')
+})

package/src/core/utils/request/toPublicUrl.ts

@@ -0,0 +1,15 @@
+/**
+ * Returns a relative URL if the given request URL is relative
+ * to the current origin. Otherwise returns an absolute URL.
+ */
+export function toPublicUrl(url: string | URL): string {
+  if (typeof location === 'undefined') {
+    return url.toString()
+  }
+
+  const urlInstance = url instanceof URL ? url : new URL(url)
+
+  return urlInstance.origin === location.origin
+    ? urlInstance.pathname
+    : urlInstance.origin + urlInstance.pathname
+}

package/lib/core/utils/request/getPublicUrlFromRequest.d.mts

@@ -1,7 +0,0 @@
-/**
- * Returns a relative URL if the given request URL is relative to the current origin.
- * Otherwise returns an absolute URL.
- */
-declare function getPublicUrlFromRequest(request: Request): string;
-
-export { getPublicUrlFromRequest };

package/lib/core/utils/request/getPublicUrlFromRequest.d.ts

@@ -1,7 +0,0 @@
-/**
- * Returns a relative URL if the given request URL is relative to the current origin.
- * Otherwise returns an absolute URL.
- */
-declare function getPublicUrlFromRequest(request: Request): string;
-
-export { getPublicUrlFromRequest };

package/lib/core/utils/request/getPublicUrlFromRequest.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/core/utils/request/getPublicUrlFromRequest.ts"],"sourcesContent":["/**\n * Returns a relative URL if the given request URL is relative to the current origin.\n * Otherwise returns an absolute URL.\n */\nexport function getPublicUrlFromRequest(request: Request): string {\n  if (typeof location === 'undefined') {\n    return request.url\n  }\n\n  const url = new URL(request.url)\n\n  return url.origin === location.origin\n    ? url.pathname\n    : url.origin + url.pathname\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIO,SAAS,wBAAwB,SAA0B;AAChE,MAAI,OAAO,aAAa,aAAa;AACnC,WAAO,QAAQ;AAAA,EACjB;AAEA,QAAM,MAAM,IAAI,IAAI,QAAQ,GAAG;AAE/B,SAAO,IAAI,WAAW,SAAS,SAC3B,IAAI,WACJ,IAAI,SAAS,IAAI;AACvB;","names":[]}

package/lib/core/utils/request/getPublicUrlFromRequest.mjs

@@ -1,11 +0,0 @@
-function getPublicUrlFromRequest(request) {
-  if (typeof location === "undefined") {
-    return request.url;
-  }
-  const url = new URL(request.url);
-  return url.origin === location.origin ? url.pathname : url.origin + url.pathname;
-}
-export {
-  getPublicUrlFromRequest
-};
-//# sourceMappingURL=getPublicUrlFromRequest.mjs.map