msw 1.3.2 → 2.0.0

package/lib/core/handlers/RequestHandler.mjs

@@ -0,0 +1,162 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { invariant } from "outvariant";
+import { getCallFrame } from '../utils/internal/getCallFrame.mjs';
+import { isIterable } from '../utils/internal/isIterable.mjs';
+class RequestHandler {
+  constructor(args) {
+    this.resolver = args.resolver;
+    this.options = args.options;
+    const callFrame = getCallFrame(new Error());
+    this.info = __spreadProps(__spreadValues({}, args.info), {
+      callFrame
+    });
+    this.isUsed = false;
+  }
+  /**
+   * Parse the intercepted request to extract additional information from it.
+   * Parsed result is then exposed to other methods of this request handler.
+   */
+  parse(_args) {
+    return __async(this, null, function* () {
+      return {};
+    });
+  }
+  /**
+   * Test if this handler matches the given request.
+   */
+  test(args) {
+    return __async(this, null, function* () {
+      const parsedResult = yield this.parse({
+        request: args.request,
+        resolutionContext: args.resolutionContext
+      });
+      return this.predicate({
+        request: args.request,
+        parsedResult,
+        resolutionContext: args.resolutionContext
+      });
+    });
+  }
+  extendResolverArgs(_args) {
+    return {};
+  }
+  /**
+   * Execute this request handler and produce a mocked response
+   * using the given resolver function.
+   */
+  run(args) {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isUsed && ((_a = this.options) == null ? void 0 : _a.once)) {
+        return null;
+      }
+      const mainRequestRef = args.request.clone();
+      this.isUsed = true;
+      const parsedResult = yield this.parse({
+        request: args.request,
+        resolutionContext: args.resolutionContext
+      });
+      const shouldInterceptRequest = this.predicate({
+        request: args.request,
+        parsedResult,
+        resolutionContext: args.resolutionContext
+      });
+      if (!shouldInterceptRequest) {
+        return null;
+      }
+      const executeResolver = this.wrapResolver(this.resolver);
+      const resolverExtras = this.extendResolverArgs({
+        request: args.request,
+        parsedResult
+      });
+      const mockedResponse = yield executeResolver(__spreadProps(__spreadValues({}, resolverExtras), {
+        request: args.request
+      }));
+      const executionResult = this.createExecutionResult({
+        // Pass the cloned request to the result so that logging
+        // and other consumers could read its body once more.
+        request: mainRequestRef,
+        response: mockedResponse,
+        parsedResult
+      });
+      return executionResult;
+    });
+  }
+  wrapResolver(resolver) {
+    return (info) => __async(this, null, function* () {
+      const result = this.resolverGenerator || (yield resolver(info));
+      if (isIterable(result)) {
+        this.isUsed = false;
+        const { value, done } = result[Symbol.iterator]().next();
+        const nextResponse = yield value;
+        if (done) {
+          this.isUsed = true;
+        }
+        if (!nextResponse && done) {
+          invariant(
+            this.resolverGeneratorResult,
+            "Failed to returned a previously stored generator response: the value is not a valid Response."
+          );
+          return this.resolverGeneratorResult.clone();
+        }
+        if (!this.resolverGenerator) {
+          this.resolverGenerator = result;
+        }
+        if (nextResponse) {
+          this.resolverGeneratorResult = nextResponse == null ? void 0 : nextResponse.clone();
+        }
+        return nextResponse;
+      }
+      return result;
+    });
+  }
+  createExecutionResult(args) {
+    return {
+      handler: this,
+      request: args.request,
+      response: args.response,
+      parsedResult: args.parsedResult
+    };
+  }
+}
+export {
+  RequestHandler
+};

package/lib/core/http.d.ts

@@ -0,0 +1,26 @@
+import { D as DefaultBodyType, a as ResponseResolver, c as RequestHandlerOptions } from './RequestHandler-1a5dbdc7.js';
+import { HttpRequestResolverExtras, HttpHandler } from './handlers/HttpHandler.js';
+import { PathParams, Path } from './utils/matching/matchRequestUrl.js';
+import './typeUtils.js';
+
+/**
+ * A namespace to intercept and mock HTTP requests.
+ *
+ * @example
+ * http.get('/user', resolver)
+ * http.post('/post/:id', resolver)
+ *
+ * @see {@link https://mswjs.io/docs/api/http `http` API reference}
+ */
+declare const http: {
+    all: <Params extends PathParams<keyof Params> = PathParams, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<Params>, RequestBodyType, ResponseBodyType>, options?: RequestHandlerOptions) => HttpHandler;
+    head: <Params_1 extends PathParams<keyof Params_1> = PathParams, RequestBodyType_1 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_1 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<Params_1>, RequestBodyType_1, ResponseBodyType_1>, options?: RequestHandlerOptions) => HttpHandler;
+    get: <Params_2 extends PathParams<keyof Params_2> = PathParams, RequestBodyType_2 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_2 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<Params_2>, RequestBodyType_2, ResponseBodyType_2>, options?: RequestHandlerOptions) => HttpHandler;
+    post: <Params_3 extends PathParams<keyof Params_3> = PathParams, RequestBodyType_3 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_3 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<Params_3>, RequestBodyType_3, ResponseBodyType_3>, options?: RequestHandlerOptions) => HttpHandler;
+    put: <Params_4 extends PathParams<keyof Params_4> = PathParams, RequestBodyType_4 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_4 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<Params_4>, RequestBodyType_4, ResponseBodyType_4>, options?: RequestHandlerOptions) => HttpHandler;
+    delete: <Params_5 extends PathParams<keyof Params_5> = PathParams, RequestBodyType_5 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_5 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<Params_5>, RequestBodyType_5, ResponseBodyType_5>, options?: RequestHandlerOptions) => HttpHandler;
+    patch: <Params_6 extends PathParams<keyof Params_6> = PathParams, RequestBodyType_6 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_6 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<Params_6>, RequestBodyType_6, ResponseBodyType_6>, options?: RequestHandlerOptions) => HttpHandler;
+    options: <Params_7 extends PathParams<keyof Params_7> = PathParams, RequestBodyType_7 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_7 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<Params_7>, RequestBodyType_7, ResponseBodyType_7>, options?: RequestHandlerOptions) => HttpHandler;
+};
+
+export { http };

package/lib/core/http.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var http_exports = {};
+__export(http_exports, {
+  http: () => http
+});
+module.exports = __toCommonJS(http_exports);
+var import_HttpHandler = require("./handlers/HttpHandler.js");
+function createHttpHandler(method) {
+  return (path, resolver, options = {}) => {
+    return new import_HttpHandler.HttpHandler(method, path, resolver, options);
+  };
+}
+const http = {
+  all: createHttpHandler(/.+/),
+  head: createHttpHandler(import_HttpHandler.HttpMethods.HEAD),
+  get: createHttpHandler(import_HttpHandler.HttpMethods.GET),
+  post: createHttpHandler(import_HttpHandler.HttpMethods.POST),
+  put: createHttpHandler(import_HttpHandler.HttpMethods.PUT),
+  delete: createHttpHandler(import_HttpHandler.HttpMethods.DELETE),
+  patch: createHttpHandler(import_HttpHandler.HttpMethods.PATCH),
+  options: createHttpHandler(import_HttpHandler.HttpMethods.OPTIONS)
+};

package/lib/core/http.mjs

@@ -0,0 +1,22 @@
+import {
+  HttpMethods,
+  HttpHandler
+} from './handlers/HttpHandler.mjs';
+function createHttpHandler(method) {
+  return (path, resolver, options = {}) => {
+    return new HttpHandler(method, path, resolver, options);
+  };
+}
+const http = {
+  all: createHttpHandler(/.+/),
+  head: createHttpHandler(HttpMethods.HEAD),
+  get: createHttpHandler(HttpMethods.GET),
+  post: createHttpHandler(HttpMethods.POST),
+  put: createHttpHandler(HttpMethods.PUT),
+  delete: createHttpHandler(HttpMethods.DELETE),
+  patch: createHttpHandler(HttpMethods.PATCH),
+  options: createHttpHandler(HttpMethods.OPTIONS)
+};
+export {
+  http
+};

package/lib/core/http.spec.d.ts

@@ -0,0 +1,2 @@
+
+export { }

package/lib/core/http.spec.js

@@ -0,0 +1,15 @@
+"use strict";
+var import_http = require("./http.js");
+test("exports all REST API methods", () => {
+  expect(import_http.http).toBeDefined();
+  expect(Object.keys(import_http.http)).toEqual([
+    "all",
+    "head",
+    "get",
+    "post",
+    "put",
+    "delete",
+    "patch",
+    "options"
+  ]);
+});

package/lib/core/http.spec.mjs

@@ -0,0 +1,14 @@
+import { http } from './http.mjs';
+test("exports all REST API methods", () => {
+  expect(http).toBeDefined();
+  expect(Object.keys(http)).toEqual([
+    "all",
+    "head",
+    "get",
+    "post",
+    "put",
+    "delete",
+    "patch",
+    "options"
+  ]);
+});

package/lib/core/index.d.ts

@@ -0,0 +1,18 @@
+export { SetupApi } from './SetupApi.js';
+export { A as AsyncResponseResolverReturnType, D as DefaultBodyType, d as DefaultRequestMultipartBody, f as HttpResponse, H as HttpResponseInit, R as RequestHandler, c as RequestHandlerOptions, a as ResponseResolver, b as ResponseResolverReturnType, S as StrictRequest, e as StrictResponse } from './RequestHandler-1a5dbdc7.js';
+export { http } from './http.js';
+export { HttpHandler, HttpMethods, HttpRequestParsedResult, RequestQuery } from './handlers/HttpHandler.js';
+export { graphql } from './graphql.js';
+export { G as GraphQLHandler, c as GraphQLJsonRequestBody, b as GraphQLRequestBody, a as GraphQLVariables, P as ParsedGraphQLRequest } from './GraphQLHandler-b42ca96f.js';
+export { Match, Path, PathParams, matchRequestUrl } from './utils/matching/matchRequestUrl.js';
+export { HandleRequestOptions, handleRequest } from './utils/handleRequest.js';
+export { cleanUrl } from './utils/url/cleanUrl.js';
+export { LifeCycleEventsMap, SharedOptions } from './sharedOptions.js';
+export { DelayMode, MAX_SERVER_RESPONSE_TIME, MIN_SERVER_RESPONSE_TIME, NODE_SERVER_RESPONSE_TIME, SET_TIMEOUT_MAX_ALLOWED_INT, delay } from './delay.js';
+export { bypass } from './bypass.js';
+export { passthrough } from './passthrough.js';
+import 'strict-event-emitter';
+import './utils/internal/Disposable.js';
+import './typeUtils.js';
+import 'graphql';
+import './utils/request/onUnhandledRequest.js';

package/lib/core/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var core_exports = {};
+__export(core_exports, {
+  GraphQLHandler: () => import_GraphQLHandler.GraphQLHandler,
+  HttpHandler: () => import_HttpHandler.HttpHandler,
+  HttpMethods: () => import_HttpHandler.HttpMethods,
+  RequestHandler: () => import_RequestHandler.RequestHandler,
+  SetupApi: () => import_SetupApi.SetupApi,
+  bypass: () => import_bypass.bypass,
+  cleanUrl: () => import_cleanUrl.cleanUrl,
+  graphql: () => import_graphql.graphql,
+  http: () => import_http.http,
+  matchRequestUrl: () => import_matchRequestUrl.matchRequestUrl,
+  passthrough: () => import_passthrough.passthrough
+});
+module.exports = __toCommonJS(core_exports);
+var import_checkGlobals = require("./utils/internal/checkGlobals.js");
+var import_SetupApi = require("./SetupApi.js");
+var import_RequestHandler = require("./handlers/RequestHandler.js");
+var import_http = require("./http.js");
+var import_HttpHandler = require("./handlers/HttpHandler.js");
+var import_graphql = require("./graphql.js");
+var import_GraphQLHandler = require("./handlers/GraphQLHandler.js");
+var import_matchRequestUrl = require("./utils/matching/matchRequestUrl.js");
+__reExport(core_exports, require("./utils/handleRequest.js"), module.exports);
+var import_cleanUrl = require("./utils/url/cleanUrl.js");
+__reExport(core_exports, require("./HttpResponse.js"), module.exports);
+__reExport(core_exports, require("./delay.js"), module.exports);
+var import_bypass = require("./bypass.js");
+var import_passthrough = require("./passthrough.js");
+(0, import_checkGlobals.checkGlobals)();

package/lib/core/index.mjs

@@ -0,0 +1,28 @@
+import { checkGlobals } from './utils/internal/checkGlobals.mjs';
+import { SetupApi } from './SetupApi.mjs';
+import { RequestHandler } from './handlers/RequestHandler.mjs';
+import { http } from './http.mjs';
+import { HttpHandler, HttpMethods } from './handlers/HttpHandler.mjs';
+import { graphql } from './graphql.mjs';
+import { GraphQLHandler } from './handlers/GraphQLHandler.mjs';
+import { matchRequestUrl } from './utils/matching/matchRequestUrl.mjs';
+export * from './utils/handleRequest.mjs';
+import { cleanUrl } from './utils/url/cleanUrl.mjs';
+export * from './HttpResponse.mjs';
+export * from './delay.mjs';
+import { bypass } from './bypass.mjs';
+import { passthrough } from './passthrough.mjs';
+checkGlobals();
+export {
+  GraphQLHandler,
+  HttpHandler,
+  HttpMethods,
+  RequestHandler,
+  SetupApi,
+  bypass,
+  cleanUrl,
+  graphql,
+  http,
+  matchRequestUrl,
+  passthrough
+};

package/lib/core/passthrough.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Performs the intercepted request as-is.
+ *
+ * This stops request handler lookup so no other handlers
+ * can affect this request past this point.
+ * Unlike `bypass()`, this will not trigger an additional request.
+ *
+ * @example
+ * http.get('/resource', () => {
+ *   return passthrough()
+ * })
+ *
+ * @see {@link https://mswjs.io/docs/api/passthrough `passthrough()` API reference}
+ */
+declare function passthrough(): Response;
+
+export { passthrough };

package/lib/core/passthrough.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var passthrough_exports = {};
+__export(passthrough_exports, {
+  passthrough: () => passthrough
+});
+module.exports = __toCommonJS(passthrough_exports);
+function passthrough() {
+  return new Response(null, {
+    status: 302,
+    statusText: "Passthrough",
+    headers: {
+      "x-msw-intention": "passthrough"
+    }
+  });
+}

package/lib/core/passthrough.mjs

@@ -0,0 +1,12 @@
+function passthrough() {
+  return new Response(null, {
+    status: 302,
+    statusText: "Passthrough",
+    headers: {
+      "x-msw-intention": "passthrough"
+    }
+  });
+}
+export {
+  passthrough
+};

package/lib/core/sharedOptions.d.ts

@@ -0,0 +1,66 @@
+import { Emitter } from 'strict-event-emitter';
+import { UnhandledRequestStrategy } from './utils/request/onUnhandledRequest.js';
+import './RequestHandler-1a5dbdc7.js';
+import './typeUtils.js';
+
+interface SharedOptions {
+    /**
+     * Specifies how to react to a request that has no corresponding
+     * request handler. Warns on unhandled requests by default.
+     *
+     * @example worker.start({ onUnhandledRequest: 'bypass' })
+     * @example worker.start({ onUnhandledRequest: 'warn' })
+     * @example server.listen({ onUnhandledRequest: 'error' })
+     */
+    onUnhandledRequest?: UnhandledRequestStrategy;
+}
+type LifeCycleEventsMap = {
+    'request:start': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:match': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:unhandled': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:end': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'response:mocked': [
+        args: {
+            response: Response;
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'response:bypass': [
+        args: {
+            response: Response;
+            request: Request;
+            requestId: string;
+        }
+    ];
+    unhandledException: [
+        args: {
+            error: Error;
+            request: Request;
+            requestId: string;
+        }
+    ];
+};
+type LifeCycleEventEmitter<EventsMap extends Record<string | symbol, any>> = Pick<Emitter<EventsMap>, 'on' | 'removeListener' | 'removeAllListeners'>;
+
+export { LifeCycleEventEmitter, LifeCycleEventsMap, SharedOptions };

package/lib/core/sharedOptions.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sharedOptions_exports = {};
+module.exports = __toCommonJS(sharedOptions_exports);

package/lib/core/typeUtils.d.ts

@@ -0,0 +1,7 @@
+type Fn = (...arg: any[]) => any;
+type MaybePromise<T> = T | Promise<T>;
+type RequiredDeep<Type, U extends Record<string, unknown> | Fn | undefined = undefined> = Type extends Fn ? Type : Type extends Record<string, any> ? {
+    [Key in keyof Type]-?: NonNullable<Type[Key]> extends NonNullable<U> ? NonNullable<Type[Key]> : RequiredDeep<NonNullable<Type[Key]>, U>;
+} : Type;
+
+export { MaybePromise, RequiredDeep };

package/lib/core/typeUtils.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var typeUtils_exports = {};
+module.exports = __toCommonJS(typeUtils_exports);

package/lib/core/utils/HttpResponse/decorators.d.ts

@@ -0,0 +1,12 @@
+import { H as HttpResponseInit } from '../../RequestHandler-1a5dbdc7.js';
+import '../../typeUtils.js';
+
+interface HttpResponseDecoratedInit extends HttpResponseInit {
+    status: number;
+    statusText: string;
+    headers: Headers;
+}
+declare function normalizeResponseInit(init?: HttpResponseInit): HttpResponseDecoratedInit;
+declare function decorateResponse(response: Response, init: HttpResponseDecoratedInit): Response;
+
+export { HttpResponseDecoratedInit, decorateResponse, normalizeResponseInit };

package/lib/core/utils/HttpResponse/decorators.js

@@ -0,0 +1,80 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var decorators_exports = {};
+__export(decorators_exports, {
+  decorateResponse: () => decorateResponse,
+  normalizeResponseInit: () => normalizeResponseInit
+});
+module.exports = __toCommonJS(decorators_exports);
+var import_statuses = __toESM(require("@bundled-es-modules/statuses"));
+const { message } = import_statuses.default;
+function normalizeResponseInit(init = {}) {
+  const status = (init == null ? void 0 : init.status) || 200;
+  const statusText = (init == null ? void 0 : init.statusText) || message[status] || "";
+  const headers = new Headers(init == null ? void 0 : init.headers);
+  return __spreadProps(__spreadValues({}, init), {
+    headers,
+    status,
+    statusText
+  });
+}
+function decorateResponse(response, init) {
+  var _a;
+  if (init.type) {
+    Object.defineProperty(response, "type", {
+      value: init.type,
+      enumerable: true,
+      writable: false
+    });
+  }
+  if (typeof document !== "undefined") {
+    const responseCookies = ((_a = init.headers.get("Set-Cookie")) == null ? void 0 : _a.split(",")) || [];
+    for (const cookieString of responseCookies) {
+      document.cookie = cookieString;
+    }
+  }
+  return response;
+}