@d1g1tal/transportr 0.1.6 → 1.1.0

package/dist/transportr.js

@@ -54,45 +54,33 @@ var Transportr = (() => {
   var _type = (object) => object?.constructor ?? object?.prototype?.constructor ?? globalThis[Object.prototype.toString.call(object).slice(8, -1)] ?? object;
   var object_type_default = _type;
 
-  // node_modules/@d1g1tal/chrysalis/src/esm/object-is-type.js
-  var _isType = (object, type) => object_type_default(object) === type;
-  var object_is_type_default = _isType;
+  // node_modules/@d1g1tal/chrysalis/src/esm/object-is-empty.js
+  var _objectIsEmpty = (object) => !!object && Object.keys(object).length === 0 && object.constructor === Object;
+  var object_is_empty_default = _objectIsEmpty;
 
   // node_modules/@d1g1tal/chrysalis/src/esm/object-merge.js
   var _objectMerge = (...objects) => {
-    return objects.reduce((previousValue, currentValue) => {
-      for (const [key, value] of Object.entries(currentValue)) {
-        switch (true) {
-          case (Array.isArray(value) && Array.isArray(previousValue[key])): {
-            previousValue[key] = [.../* @__PURE__ */ new Set([...value, ...previousValue[key]])];
-            break;
+    const target = {};
+    for (const source of objects) {
+      if (object_type_default(source) != Object)
+        return void 0;
+      let descriptor, sourceType;
+      for (const property of Object.getOwnPropertyNames(source)) {
+        descriptor = Object.getOwnPropertyDescriptor(source, property);
+        if (descriptor.enumerable) {
+          sourceType = object_type_default(source[property]);
+          if (sourceType == Object) {
+            descriptor.value = object_type_default(target[property]) == Object ? _objectMerge(target[property], source[property]) : { ...source[property] };
+          } else if (sourceType == Array) {
+            descriptor.value = Array.isArray(target[property]) ? [.../* @__PURE__ */ new Set([...source[property], ...target[property]])] : [...source[property]];
           }
-          case (object_is_type_default(value, Object) && object_is_type_default(previousValue[key], Object)): {
-            previousValue[key] = _objectMerge(previousValue[key], value);
-            break;
-          }
-          default:
-            previousValue[key] = value;
+          target[property] = descriptor.value;
         }
       }
-      return previousValue;
-    }, {});
-  };
-  var object_merge_default = _objectMerge;
-
-  // node_modules/@d1g1tal/chrysalis/src/esm/is-iterable.js
-  var _isIterable = (input) => !!input?.[Symbol.iterator];
-  var is_iterable_default = _isIterable;
-
-  // node_modules/@d1g1tal/chrysalis/src/esm/object-construct.js
-  var _construct = (value, args = []) => {
-    try {
-      return Reflect.construct(value, args);
-    } catch (error) {
-      return value(...args);
     }
+    return target;
   };
-  var object_construct_default = _construct;
+  var object_merge_default = _objectMerge;
 
   // node_modules/@d1g1tal/collections/src/set-multi-map.js
   var SetMultiMap = class extends Map {
@@ -518,6 +506,130 @@ var Transportr = (() => {
     }
   };
 
+  // node_modules/@d1g1tal/subscribr/src/context-event-handler.js
+  var ContextEventHandler = class {
+    #context;
+    #eventHandler;
+    /**
+     * @param {*} context The context to bind to the event handler.
+     * @param {function(*): void} eventHandler The event handler to call when the event is published.
+     */
+    constructor(context, eventHandler) {
+      this.#context = context;
+      this.#eventHandler = eventHandler;
+    }
+    /**
+     * Call the event handler for the provided event.
+     *
+     * @param {Event} event The event to handle
+     * @param {*} [data] The value to be passed to the event handler as a parameter.
+     */
+    handle(event, data) {
+      this.#eventHandler.call(this.#context, event, data);
+    }
+    get [Symbol.toStringTag]() {
+      return "ContextEventHandler";
+    }
+  };
+
+  // node_modules/@d1g1tal/subscribr/src/subscription.js
+  var Subscription = class {
+    #eventName;
+    #contextEventHandler;
+    /**
+     * @param {string} eventName The event name.
+     * @param {ContextEventHandler} contextEventHandler Then context event handler.
+     */
+    constructor(eventName, contextEventHandler) {
+      this.#eventName = eventName;
+      this.#contextEventHandler = contextEventHandler;
+    }
+    /**
+     * Gets the event name for the subscription.
+     *
+     * @returns {string} The event name.
+     */
+    get eventName() {
+      return this.#eventName;
+    }
+    /**
+     * Gets the context event handler.
+     *
+     * @returns {ContextEventHandler} The context event handler
+     */
+    get contextEventHandler() {
+      return this.#contextEventHandler;
+    }
+    get [Symbol.toStringTag]() {
+      return "Subscription";
+    }
+  };
+
+  // node_modules/@d1g1tal/subscribr/src/subscribr.js
+  var Subscribr = class {
+    /** @type {SetMultiMap<string, ContextEventHandler>} */
+    #subscribers;
+    constructor() {
+      this.#subscribers = new SetMultiMap();
+    }
+    /**
+     * Subscribe to an event
+     *
+     * @param {string} eventName The event name to subscribe to.
+     * @param {function(Event, *): void} eventHandler The event handler to call when the event is published.
+     * @param {*} [context] The context to bind to the event handler.
+     * @returns {Subscription} An object used to check if the subscription still exists and to unsubscribe from the event.
+     */
+    subscribe(eventName, eventHandler, context = eventHandler) {
+      const contextEventHandler = new ContextEventHandler(context, eventHandler);
+      this.#subscribers.set(eventName, contextEventHandler);
+      return new Subscription(eventName, contextEventHandler);
+    }
+    /**
+     * Unsubscribe from the event
+     *
+     * @param {Subscription} subscription The subscription to unsubscribe.
+     * @param {string} subscription.eventName The event name to subscribe to.
+     * @param {ContextEventHandler} subscription.contextEventHandler The event handler to call when the event is published.
+     * @returns {boolean} true if eventListener has been removed successfully. false if the value is not found or if the value is not an object.
+     */
+    unsubscribe({ eventName, contextEventHandler }) {
+      const contextEventHandlers = this.#subscribers.get(eventName);
+      const removed = contextEventHandlers?.delete(contextEventHandler);
+      if (removed && contextEventHandlers.size == 0) {
+        this.#subscribers.delete(eventName);
+      }
+      return removed;
+    }
+    /**
+     * Publish an event
+     *
+     * @param {string} eventName The name of the event.
+     * @param {Event} event The event to be handled.
+     * @param {*} [data] The value to be passed to the event handler as a parameter.
+     */
+    publish(eventName, event = new CustomEvent(eventName), data) {
+      if (data == null && !(event instanceof Event)) {
+        [data, event] = [event, new CustomEvent(eventName)];
+      }
+      this.#subscribers.get(eventName)?.forEach((contextEventHandler) => contextEventHandler.handle(event, data));
+    }
+    /**
+     * Check if the event and handler are subscribed.
+     *
+     * @param {Subscription} subscription The subscription object.
+     * @param {string} subscription.eventName The name of the event to check.
+     * @param {ContextEventHandler} subscription.contextEventHandler The event handler to check.
+     * @returns {boolean} true if the event name and handler are subscribed, false otherwise.
+     */
+    isSubscribed({ eventName, contextEventHandler }) {
+      return this.#subscribers.get(eventName)?.has(contextEventHandler);
+    }
+    get [Symbol.toStringTag]() {
+      return "Subscribr";
+    }
+  };
+
   // src/http-error.js
   var HttpError = class extends Error {
     /** @type {ResponseBody} */
@@ -1706,6 +1818,47 @@ var Transportr = (() => {
     }
   };
 
+  // src/signal-controller.js
+  var SignalController = class {
+    /** @type {AbortController} */
+    #abortController;
+    /**
+     * @param {AbortSignal} [signal] The signal to be used to abort the request.
+     */
+    constructor(signal) {
+      this.#abortController = new AbortController();
+      signal?.addEventListener("abort", () => this.#abortController.abort());
+    }
+    /**
+     * Returns the {@link AbortSignal} object associated with this object.
+     *
+     * @returns {AbortSignal} The {@link AbortSignal} object associated with this object.
+     */
+    get signal() {
+      return this.#abortController.signal;
+    }
+    /**
+     * Aborts a DOM request before it has completed.
+     * This is able to abort fetch requests, data sent using the XMLHttpRequest API, and Web Sockets.
+     *
+     * @param {DOMException} [reason] The reason for aborting the request.
+     * @returns {void}
+     */
+    abort(reason) {
+      this.#abortController.abort(reason);
+    }
+    /**
+     * A String value that is used in the creation of the default string
+     * description of an object. Called by the built-in method {@link Object.prototype.toString}.
+     *
+     * @override
+     * @returns {string} The default string description of this object.
+     */
+    get [Symbol.toStringTag]() {
+      return "SignalController";
+    }
+  };
+
   // src/transportr.js
   var endsWithSlashRegEx = /\/$/;
   var _handleText = async (response) => await response.text();
@@ -1729,13 +1882,14 @@ var Transportr = (() => {
   var _handleXml = async (response) => new DOMParser().parseFromString(await response.text(), http_media_type_default.XML.essence);
   var _handleHtml = async (response) => new DOMParser().parseFromString(await response.text(), http_media_type_default.HTML.essence);
   var _handleHtmlFragment = async (response) => document.createRange().createContextualFragment(await response.text());
-  var _baseUrl, _options, _contentTypeHandlers, _defaultRequestOptions, _get, get_fn, _request, request_fn, _processResponse, processResponse_fn, _createUrl, createUrl_fn, _needsSerialization, needsSerialization_fn, _convertRequestOptions, convertRequestOptions_fn;
+  var _typeConverter = (data) => Object.fromEntries(Array.from(data.keys()).map((key, index, keys, value = data.getAll(key)) => [key, value.length > 1 ? value : value[0]]));
+  var _baseUrl, _options, _subscribr, _globalSubscribr, _contentTypeHandlers, _propertyTypeConverters, _defaultRequestOptions, _eventResponseStatuses, _get, get_fn, _request, request_fn, _throwHttpError, throwHttpError_fn, _publish, publish_fn, _generateResponseStatusFromError, generateResponseStatusFromError_fn, _processResponse, processResponse_fn, _createUrl, createUrl_fn, _needsSerialization, needsSerialization_fn, _convertRequestOptions, convertRequestOptions_fn;
   var _Transportr = class {
     /**
      * Create a new Transportr instance with the provided location or origin and context path.
      *
-     * @param {URL | string | RequestOptions} [url=location.origin] The URL for {@link fetch} requests.
-     * @param {RequestOptions} [options=Transportr.#defaultRequestOptions] The default {@link RequestOptions} for this instance.
+     * @param {URL|string|RequestOptions} [url=location.origin] The URL for {@link fetch} requests.
+     * @param {RequestOptions} [options={}] The default {@link RequestOptions} for this instance.
      */
     constructor(url = location.origin, options = {}) {
       /**
@@ -1765,10 +1919,31 @@ var Transportr = (() => {
        * @returns {Promise<ResponseBody>} The response from the API call.
        */
       __privateAdd(this, _request);
+      /**
+       * Handles an error by logging it and throwing it.
+       *
+       * @private
+       * @param {URL} url The path to the resource you want to access.
+       * @param {import('./http-error.js').HttpErrorOptions} options The options for the HttpError.
+       * @returns {void}
+       */
+      __privateAdd(this, _throwHttpError);
+      /**
+       * Publishes an event to the global and instance subscribers.
+       *
+       * @private
+       * @param {string} eventName The name of the event.
+       * @param {Event} event The event object.
+       * @param {*} data The data to pass to the subscribers.
+       * @returns {void}
+       */
+      __privateAdd(this, _publish);
       /** @type {URL} */
       __privateAdd(this, _baseUrl, void 0);
       /** @type {RequestOptions} */
       __privateAdd(this, _options, void 0);
+      /** @type {Subscribr} */
+      __privateAdd(this, _subscribr, void 0);
       var _a;
       const type = object_type_default(url);
       if (type == Object) {
@@ -1778,7 +1953,39 @@ var Transportr = (() => {
         url = url.startsWith("/") ? new URL(url, location.origin) : new URL(url);
       }
       __privateSet(this, _baseUrl, url);
-      __privateSet(this, _options, object_merge_default(__privateGet(_Transportr, _defaultRequestOptions), __privateMethod(_a = _Transportr, _convertRequestOptions, convertRequestOptions_fn).call(_a, options, { headers: Object, searchParams: Object })));
+      __privateSet(this, _options, object_merge_default(__privateGet(_Transportr, _defaultRequestOptions), __privateMethod(_a = _Transportr, _convertRequestOptions, convertRequestOptions_fn).call(_a, options)));
+      __privateSet(this, _subscribr, new Subscribr());
+    }
+    /**
+     * Returns a {@link SignalController} used for aborting requests.
+     *
+     * @static
+     * @returns {SignalController} A new {@link SignalController} instance.
+     */
+    static signalController() {
+      return new SignalController();
+    }
+    /**
+     * Returns a {@link EventRegistration} used for subscribing to global events.
+     *
+     * @static
+     * @param {TransportrEvent} event The event to subscribe to.
+     * @param {function(Event, *): void} handler The event handler.
+     * @param {*} context The context to bind the handler to.
+     * @returns {EventRegistration} A new {@link EventRegistration} instance.
+     */
+    static register(event, handler, context) {
+      return __privateGet(_Transportr, _globalSubscribr).subscribe(event, handler, context);
+    }
+    /**
+     * Removes a {@link EventRegistration} from the global event handler.
+     *
+     * @static
+     * @param {EventRegistration} eventRegistration The {@link EventRegistration} to remove.
+     * @returns {boolean} True if the {@link EventRegistration} was removed, false otherwise.
+     */
+    static unregister(eventRegistration) {
+      return __privateGet(_Transportr, _globalSubscribr).unsubscribe(eventRegistration);
     }
     /**
      * It returns the base {@link URL} for the API.
@@ -1788,6 +1995,26 @@ var Transportr = (() => {
     get baseUrl() {
       return __privateGet(this, _baseUrl);
     }
+    /**
+     * Registers an event handler with a {@link Transportr} instance.
+     *
+     * @param {TransportrEvent} event The name of the event to listen for.
+     * @param {function(Event, *): void} handler The function to call when the event is triggered.
+     * @param {*} [context] The context to bind to the handler.
+     * @returns {EventRegistration} An object that can be used to remove the event handler.
+     */
+    register(event, handler, context) {
+      return __privateGet(this, _subscribr).subscribe(event, handler, context);
+    }
+    /**
+     * Unregisters an event handler from a {@link Transportr} instance.
+     *
+     * @param {EventRegistration} eventRegistration The event registration to remove.
+     * @returns {void}
+     */
+    unregister(eventRegistration) {
+      __privateGet(this, _subscribr).unsubscribe(eventRegistration);
+    }
     /**
      * This function returns a promise that resolves to the result of a request to the specified path with
      * the specified options, where the method is GET.
@@ -1810,7 +2037,7 @@ var Transportr = (() => {
      * @returns {Promise<ResponseBody>} A promise that resolves to the response body.
      */
     async post(path, body, options) {
-      return __privateMethod(this, _request, request_fn).call(this, path, options, { body, method: http_request_methods_default.POST });
+      return __privateMethod(this, _request, request_fn).call(this, path, { ...options, body }, { method: http_request_methods_default.POST });
     }
     /**
      * This function returns a promise that resolves to the result of a request to the specified path with
@@ -2006,31 +2233,82 @@ var Transportr = (() => {
   var Transportr = _Transportr;
   _baseUrl = new WeakMap();
   _options = new WeakMap();
+  _subscribr = new WeakMap();
+  _globalSubscribr = new WeakMap();
   _contentTypeHandlers = new WeakMap();
+  _propertyTypeConverters = new WeakMap();
   _defaultRequestOptions = new WeakMap();
+  _eventResponseStatuses = new WeakMap();
   _get = new WeakSet();
   get_fn = async function(path, userOptions, options, responseHandler) {
     return __privateMethod(this, _request, request_fn).call(this, path, userOptions, options, responseHandler);
   };
   _request = new WeakSet();
   request_fn = async function(path, userOptions = {}, options = {}, responseHandler) {
-    var _a, _b, _c, _d, _e;
-    const requestOptions = __privateMethod(_a = _Transportr, _convertRequestOptions, convertRequestOptions_fn).call(_a, object_merge_default(__privateGet(this, _options), userOptions, options), { headers: Headers, searchParams: URLSearchParams });
-    const errorMessage = `An error has occurred with your Request: ${path}`;
-    if (__privateMethod(_b = _Transportr, _needsSerialization, needsSerialization_fn).call(_b, requestOptions.method, requestOptions.headers.get(http_request_headers_default.CONTENT_TYPE))) {
-      requestOptions.body = JSON.stringify(requestOptions.body);
-    }
-    let response;
+    var _a, _b, _c, _d, _e, _f, _g;
+    const requestOptions = object_merge_default(__privateGet(this, _options), __privateMethod(_a = _Transportr, _convertRequestOptions, convertRequestOptions_fn).call(_a, userOptions), options);
+    const url = __privateMethod(_b = _Transportr, _createUrl, createUrl_fn).call(_b, __privateGet(this, _baseUrl), path, requestOptions.searchParams);
+    const signalController = new SignalController(requestOptions.signal);
+    requestOptions.signal = signalController.signal;
+    if (__privateMethod(_c = _Transportr, _needsSerialization, needsSerialization_fn).call(_c, requestOptions.method, requestOptions.headers[http_request_headers_default.CONTENT_TYPE])) {
+      try {
+        requestOptions.body = JSON.stringify(requestOptions.body);
+      } catch (error) {
+        __privateMethod(this, _throwHttpError, throwHttpError_fn).call(this, url, { cause: error });
+      }
+    } else if (requestOptions.method == http_request_methods_default.GET && requestOptions.headers[http_request_headers_default.CONTENT_TYPE] != "") {
+      delete requestOptions.headers[http_request_headers_default.CONTENT_TYPE];
+      delete requestOptions.body;
+    }
+    requestOptions.signal.addEventListener("abort", (event) => __privateMethod(this, _publish, publish_fn).call(this, _Transportr.Events.ABORTED, event));
+    requestOptions.signal.addEventListener("timeout", (event) => __privateMethod(this, _publish, publish_fn).call(this, _Transportr.Events.TIMEOUT, event));
+    __privateMethod(this, _publish, publish_fn).call(this, _Transportr.Events.CONFIGURED, requestOptions);
+    let result, timeoutId, response;
     try {
-      response = await fetch(__privateMethod(_c = _Transportr, _createUrl, createUrl_fn).call(_c, __privateGet(this, _baseUrl), path, requestOptions.searchParams), requestOptions);
-    } catch (error) {
-      console.error(errorMessage, error);
-      throw new HttpError(errorMessage, { cause: error, status: new ResponseStatus(response.status, response.statusText) });
+      try {
+        timeoutId = setTimeout(() => {
+          const cause = new DOMException(`The call to '${url}' timed-out after ${requestOptions.timeout / 1e3} seconds`, "TimeoutError");
+          signalController.abort(cause);
+          requestOptions.signal.dispatchEvent(new CustomEvent(_Transportr.Events.TIMEOUT, { detail: { url, options: requestOptions, cause } }));
+        }, requestOptions.timeout);
+        response = await fetch(url, requestOptions);
+      } catch (error) {
+        __privateMethod(this, _throwHttpError, throwHttpError_fn).call(this, url, { cause: error, status: __privateMethod(_d = _Transportr, _generateResponseStatusFromError, generateResponseStatusFromError_fn).call(_d, error.name, response) });
+      }
+      if (!response.ok) {
+        __privateMethod(this, _throwHttpError, throwHttpError_fn).call(this, url, { status: __privateMethod(_e = _Transportr, _generateResponseStatusFromError, generateResponseStatusFromError_fn).call(_e, "ResponseError", response), entity: await __privateMethod(_f = _Transportr, _processResponse, processResponse_fn).call(_f, response) });
+      }
+      result = await __privateMethod(_g = _Transportr, _processResponse, processResponse_fn).call(_g, response, responseHandler);
+      __privateMethod(this, _publish, publish_fn).call(this, _Transportr.Events.SUCCESS, result);
+    } finally {
+      clearTimeout(timeoutId);
+      if (!requestOptions.signal.aborted) {
+        __privateMethod(this, _publish, publish_fn).call(this, _Transportr.Events.COMPLETE, response);
+      }
     }
-    if (!response.ok) {
-      throw new HttpError(errorMessage, { status: new ResponseStatus(response.status, response.statusText), entity: await __privateMethod(_d = _Transportr, _processResponse, processResponse_fn).call(_d, response) });
+    return result;
+  };
+  _throwHttpError = new WeakSet();
+  throwHttpError_fn = function(url, options) {
+    const error = new HttpError(`An error has occurred with your request to: '${url}'`, options);
+    __privateMethod(this, _publish, publish_fn).call(this, _Transportr.Events.ERROR, error);
+    throw error;
+  };
+  _publish = new WeakSet();
+  publish_fn = function(eventName, event, data) {
+    __privateGet(_Transportr, _globalSubscribr).publish(eventName, event, data);
+    __privateGet(this, _subscribr).publish(eventName, event, data);
+  };
+  _generateResponseStatusFromError = new WeakSet();
+  generateResponseStatusFromError_fn = function(errorName, response) {
+    switch (errorName) {
+      case "AbortError":
+        return __privateGet(_Transportr, _eventResponseStatuses).get(_Transportr.Events.ABORTED);
+      case "TimeoutError":
+        return __privateGet(_Transportr, _eventResponseStatuses).get(_Transportr.Events.TIMEOUT);
+      default:
+        return response ? new ResponseStatus(response.status, response.statusText) : new ResponseStatus(500, "Internal Server Error");
     }
-    return await __privateMethod(_e = _Transportr, _processResponse, processResponse_fn).call(_e, response, responseHandler);
   };
   _processResponse = new WeakSet();
   processResponse_fn = async function(response, handler) {
@@ -2054,9 +2332,9 @@ var Transportr = (() => {
     }
   };
   _createUrl = new WeakSet();
-  createUrl_fn = function(url, path, searchParams = new URLSearchParams()) {
+  createUrl_fn = function(url, path, searchParams = {}) {
     url = path.startsWith("/") ? new URL(`${url.pathname.replace(endsWithSlashRegEx, "")}${path}`, url.origin) : new URL(path);
-    searchParams.forEach((value, key) => url.searchParams.append(key, value));
+    Object.entries(searchParams).forEach(([key, value]) => url.searchParams.append(key, value));
     return url;
   };
   _needsSerialization = new WeakSet();
@@ -2064,16 +2342,26 @@ var Transportr = (() => {
     return contentType == http_media_type_default.JSON && [http_request_methods_default.POST, http_request_methods_default.PUT, http_request_methods_default.PATCH].includes(method);
   };
   _convertRequestOptions = new WeakSet();
-  convertRequestOptions_fn = function(options, typeConversionMap) {
-    let object;
-    for (const [property, type, option = options[property]] of Object.entries(typeConversionMap)) {
-      if (option) {
-        object = is_iterable_default(option) ? Object.fromEntries(option.entries()) : option;
-        options[property] = type == Object ? object : object_construct_default(type, [object]);
+  convertRequestOptions_fn = function(options) {
+    if (!object_is_empty_default(options)) {
+      for (const [{ property, type, converter }, option = options[property]] of __privateGet(_Transportr, _propertyTypeConverters)) {
+        if (option instanceof type) {
+          options[property] = converter(option);
+        }
       }
     }
     return options;
   };
+  /**
+   * Generates a ResponseStatus object based on the error name and the response.
+   *
+   * @private
+   * @static
+   * @param {string} errorName The name of the error.
+   * @param {Response} response The response object returned by the fetch API.
+   * @returns {ResponseStatus} The response status object.
+   */
+  __privateAdd(Transportr, _generateResponseStatusFromError);
   /**
    * It takes a response and a handler, and if the handler is not defined, it tries to find a handler
    * based on the response's content type
@@ -2094,7 +2382,7 @@ var Transportr = (() => {
    * @static
    * @param {URL} url - The URL to use as a base.
    * @param {string} path - The path to the resource. This can be a relative path or a full URL.
-   * @param {URLSearchParams} [searchParams=new URLSearchParams()] - An object containing the query parameters to be added to the URL.
+   * @param {Object<string, string>} [searchParams={}] - An object containing the query parameters to be added to the URL.
    * @returns {URL} A new URL object with the pathname and origin of the url parameter, and the path parameter
    * appended to the end of the pathname.
    */
@@ -2113,10 +2401,11 @@ var Transportr = (() => {
   /**
    *
    * @param {RequestOptions} options - The options passed to the public function to use for the request.
-   * @param {Object<string, Type>} typeConversionMap - A map of properties to convert to the specified type.
    * @returns {RequestOptions} The options to use for the request.
    */
   __privateAdd(Transportr, _convertRequestOptions);
+  /** @type {Subscribr} */
+  __privateAdd(Transportr, _globalSubscribr, new Subscribr());
   /**
    * @private
    * @static
@@ -2132,6 +2421,16 @@ var Transportr = (() => {
     [_handleXml, new MediaType(http_media_type_default.XML).subtype],
     [_handleReadableStream, new MediaType(http_media_type_default.BIN).subtype]
   ]));
+  /**
+   * @private
+   * @static
+   * @type {Set<PropertyTypeConverter>}
+   */
+  __privateAdd(Transportr, _propertyTypeConverters, /* @__PURE__ */ new Set([
+    [{ property: "body", type: FormData, converter: _typeConverter }],
+    [{ property: "searchParams", type: URLSearchParams, converter: _typeConverter }],
+    [{ property: "headers", type: Headers, converter: Object.fromEntries }]
+  ]));
   /**
    * @static
    * @constant {Object<string, HttpRequestMethod>}
@@ -2207,6 +2506,18 @@ var Transportr = (() => {
     STRICT_ORIGIN_WHEN_CROSS_ORIGIN: "strict-origin-when-cross-origin",
     UNSAFE_URL: "unsafe-url"
   }));
+  /**
+   * @static
+   * @constant {Object<string, TransportrEvent>}
+   */
+  __publicField(Transportr, "Events", Object.freeze({
+    CONFIGURED: "configured",
+    SUCCESS: "success",
+    ERROR: "error",
+    ABORTED: "aborted",
+    TIMEOUT: "timeout",
+    COMPLETE: "complete"
+  }));
   /**
    * @private
    * @static
@@ -2225,9 +2536,19 @@ var Transportr = (() => {
     redirect: _Transportr.RedirectPolicy.FOLLOW,
     referrer: "about:client",
     referrerPolicy: _Transportr.ReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN,
-    signal: null,
+    signal: void 0,
+    timeout: 1e4,
     window: null
   }));
+  /**
+   * @private
+   * @static
+   * @type {Map<TransportrEvent, ResponseStatus>}
+   */
+  __privateAdd(Transportr, _eventResponseStatuses, /* @__PURE__ */ new Map([
+    [_Transportr.Events.ABORTED, new ResponseStatus(499, "Aborted")],
+    [_Transportr.Events.TIMEOUT, new ResponseStatus(504, "Gateway Timeout")]
+  ]));
   return __toCommonJS(transportr_exports);
 })();
 window.Transportr = Transportr.default;