@dereekb/util 13.3.1 → 13.4.1

package/fetch/index.esm.js

@@ -81,9 +81,8 @@ function _is_native_reflect_construct$3() {
     function FetchRequestFactoryError(error) {
         _class_call_check$3(this, FetchRequestFactoryError);
         var _this;
-        var _error_message;
         _this = _call_super$3(this, FetchRequestFactoryError, [
-            "Fetch request failed to build due to an unexpected error: ".concat((typeof error === "undefined" ? "undefined" : _type_of$5(error)) === 'object' ? (_error_message = error.message) !== null && _error_message !== void 0 ? _error_message : '' : error)
+            "Fetch request failed to build due to an unexpected error: ".concat((typeof error === "undefined" ? "undefined" : _type_of$5(error)) === 'object' ? error.message : error)
         ]), _define_property$5(_this, "error", void 0);
         _this.error = error;
         return _this;
@@ -113,7 +112,12 @@ var FetchResponseError = /*#__PURE__*/ function(BaseError) {
     }
     return FetchResponseError;
 }(BaseError);
-function requireOkResponse(responsePromise) {
+/**
+ * Asserts that the fetch response has an ok status code, throwing a FetchResponseError if it does not.
+ *
+ * @param responsePromise - promise resolving to the fetch Response to validate
+ * @returns a promise resolving to the Response if the status is ok
+ */ function requireOkResponse(responsePromise) {
     return responsePromise.then(function(response) {
         if (!response.ok) {
             throw new FetchResponseError(response);
@@ -242,7 +246,14 @@ var FetchTimeoutError = /*#__PURE__*/ function(BaseError) {
     }
     return FetchTimeoutError;
 }(BaseError);
-function fetchTimeout(inputFetch) {
+/**
+ * Wraps a fetch function to add automatic timeout/abort support. If a timeout value
+ * is present on the RequestInit or Request and no abort signal is already provided,
+ * an AbortController is created to abort the request after the specified duration.
+ *
+ * @param inputFetch - the fetch function to wrap with timeout behavior
+ * @returns a wrapped fetch function that enforces timeouts via AbortController
+ */ function fetchTimeout(inputFetch) {
     return function(input, init) {
         var _ref;
         var controller;
@@ -268,7 +279,7 @@ function fetchTimeout(inputFetch) {
     };
 }
 
-function _array_like_to_array$2(arr, len) {
+function _array_like_to_array$3(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
@@ -387,19 +398,19 @@ function _object_spread_props$2(target, source) {
     return target;
 }
 function _sliced_to_array$2(arr, i) {
-    return _array_with_holes$2(arr) || _iterable_to_array_limit$2(arr, i) || _unsupported_iterable_to_array$2(arr, i) || _non_iterable_rest$2();
+    return _array_with_holes$2(arr) || _iterable_to_array_limit$2(arr, i) || _unsupported_iterable_to_array$3(arr, i) || _non_iterable_rest$2();
 }
 function _type_of$3(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
-function _unsupported_iterable_to_array$2(o, minLen) {
+function _unsupported_iterable_to_array$3(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$2(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$3(o, minLen);
     var n = Object.prototype.toString.call(o).slice(8, -1);
     if (n === "Object" && o.constructor) n = o.constructor.name;
     if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$3(o, minLen);
 }
 function _ts_generator$4(thisArg, body) {
     var f, y, t, _ = {
@@ -507,7 +518,7 @@ function _ts_generator$4(thisArg, body) {
  * @returns
  */ function fetchService(config) {
     var inputMakeFetch = config.makeFetch, makeRequest = config.makeRequest, baseRequest = config.baseRequest;
-    var factory = {
+    return {
         fetchRequestFactory: function fetchRequestFactory1(config) {
             return fetchRequestFactory(_object_spread$3({
                 makeRequest: makeRequest,
@@ -524,10 +535,10 @@ function _ts_generator$4(thisArg, body) {
         },
         makeRequest: config.makeRequest
     };
-    return factory;
 }
 /**
  * Default FetchHabdler
+ *
  * @param request
  * @param makeFetch
  * @returns
@@ -585,7 +596,13 @@ function _ts_generator$4(thisArg, body) {
  */ var DEFAULT_FETCH_REQUEST_FACTORY = function DEFAULT_FETCH_REQUEST_FACTORY(input, init) {
     return new Request(input, init);
 };
-function fetchRequestFactory(config) {
+/**
+ * Creates a FetchRequestFactory that builds Request objects by applying base URL resolution,
+ * base request init merging, timeout configuration, and custom request init transformations.
+ *
+ * @param config - configuration for URL resolution, base request defaults, timeout, and request init transformations
+ * @returns a FetchRequestFactory that produces fully configured Request objects
+ */ function fetchRequestFactory(config) {
     var _config_makeRequest = config.makeRequest, makeRequest = _config_makeRequest === void 0 ? DEFAULT_FETCH_REQUEST_FACTORY : _config_makeRequest, inputBaseUrl = config.baseUrl, inputBaseRequest = config.baseRequest, timeout = config.timeout, requestInitFactory = config.requestInitFactory, _config_useBaseUrlForConfiguredFetchRequests = config.useBaseUrlForConfiguredFetchRequests, useBaseUrlForConfiguredFetchRequests = _config_useBaseUrlForConfiguredFetchRequests === void 0 ? false : _config_useBaseUrlForConfiguredFetchRequests, _config_forceBaseUrlForWebsiteUrlWithPrefix = config.forceBaseUrlForWebsiteUrlWithPrefix, forceBaseUrlForWebsiteUrlWithPrefix = _config_forceBaseUrlForWebsiteUrlWithPrefix === void 0 ? useBaseUrlForConfiguredFetchRequests : _config_forceBaseUrlForWebsiteUrlWithPrefix;
     var baseUrl = inputBaseUrl ? new URL(removeTrailingSlashes(inputBaseUrl)) : undefined;
     var buildUrl = baseUrl ? function(url) {
@@ -704,7 +721,7 @@ function fetchRequestFactory(config) {
     if (inputBaseRequest != null || timeout != null) {
         var computeBaseRequest = function computeBaseRequest() {
             return _async_to_generator$4(function() {
-                var computedBaseRequest, baseRequest;
+                var computedBaseRequest;
                 return _ts_generator$4(this, function(_state) {
                     switch(_state.label){
                         case 0:
@@ -714,12 +731,11 @@ function fetchRequestFactory(config) {
                             ];
                         case 1:
                             computedBaseRequest = _state.sent();
-                            baseRequest = timeout ? _object_spread_props$2(_object_spread$3({}, computedBaseRequest), {
-                                timeout: timeout
-                            }) : computedBaseRequest;
                             return [
                                 2,
-                                baseRequest
+                                timeout ? _object_spread_props$2(_object_spread$3({}, computedBaseRequest), {
+                                    timeout: timeout
+                                }) : computedBaseRequest
                             ];
                     }
                 });
@@ -827,11 +843,18 @@ function fetchRequestFactory(config) {
         })();
     };
 }
-function mergeRequestInits(base, requestInit) {
+/**
+ * Merges two RequestInit objects, combining their headers and spreading remaining properties
+ * so that values from the second init override the base.
+ *
+ * @param base - the base RequestInit to merge onto
+ * @param requestInit - optional RequestInit whose values override the base
+ * @returns the merged RequestInit
+ */ function mergeRequestInits(base, requestInit) {
     if (requestInit) {
         var headers = mergeRequestHeaders([
             base.headers,
-            requestInit === null || requestInit === void 0 ? void 0 : requestInit.headers
+            requestInit.headers
         ]);
         return _object_spread_props$2(_object_spread$3({}, base, requestInit), {
             headers: headers
@@ -840,7 +863,13 @@ function mergeRequestInits(base, requestInit) {
         return base;
     }
 }
-function mergeRequestHeaders(inputHeadersArray) {
+/**
+ * Merges an array of HeadersInit values into a single array of key-value tuples.
+ * Later headers override earlier ones on a per-key basis while preserving multi-value support.
+ *
+ * @param inputHeadersArray - array of HeadersInit values to merge, where later entries take precedence
+ * @returns an array of [key, value] tuples representing the merged headers
+ */ function mergeRequestHeaders(inputHeadersArray) {
     var headersMap = multiValueMapBuilder();
     filterMaybeArrayValues(inputHeadersArray).forEach(function(headers) {
         var tuples = headersToHeadersTuple(headers);
@@ -858,7 +887,13 @@ function mergeRequestHeaders(inputHeadersArray) {
     });
     return headersMap.tuples();
 }
-function headersToHeadersTuple(headers) {
+/**
+ * Converts a HeadersInit value (tuple array, Headers object, or plain object) into
+ * a normalized array of [key, value] tuples.
+ *
+ * @param headers - the HeadersInit value to convert
+ * @returns an array of [key, value] string tuples
+ */ function headersToHeadersTuple(headers) {
     var tuples = [];
     if (Array.isArray(headers)) {
         // use as tuples
@@ -877,7 +912,13 @@ function headersToHeadersTuple(headers) {
     }
     return tuples;
 }
-function isFetchRequest(input) {
+/**
+ * Type guard that checks whether the given input is a fetch Request object
+ * by testing for the presence of a url property.
+ *
+ * @param input - the value to test
+ * @returns true if the input is a Request
+ */ function isFetchRequest(input) {
     return Boolean(input.url);
 }
 
@@ -1012,8 +1053,8 @@ function _ts_generator$3(thisArg, body) {
 /**
  * Creates a File object from the given input.
  *
- * @example
- * makeFileForFetch({ content: pdfBuffer, fileName: 'doc.pdf', mimeType: 'application/pdf' })
+ * @param input - configuration containing the file content, name, optional MIME type, and last modified timestamp
+ * @returns a File object constructed from the provided input
  */ function makeFileForFetch(input) {
     var options = {};
     if (input.mimeType) {
@@ -1094,7 +1135,11 @@ function fetchFileFromUrl(input, safe) {
 }
 /**
  * @deprecated Use makeFileForFetch() with FormData and context.fetch() instead.
- */ function fetchUploadFile(input) {
+ *
+ * @param input - configuration containing the upload URL, fetch function, HTTP method, and file body
+ * @returns a promise resolving to the fetch Response
+ */ // eslint-disable-next-line @typescript-eslint/no-deprecated
+function fetchUploadFile(input) {
     var _input_method;
     var inputFetch = input.fetch, url = input.url, inputBody = input.body;
     var useFetch = inputFetch !== null && inputFetch !== void 0 ? inputFetch : fetch;
@@ -1235,7 +1280,13 @@ function _ts_generator$2(thisArg, body) {
         };
     }
 }
-function rateLimitedFetchHandler(config) {
+/**
+ * Creates a FetchHandler that enforces rate limiting via the provided PromiseRateLimiter and supports
+ * automatic retry when the server signals throttling.
+ *
+ * @param config - configuration containing the rate limiter, retry settings, and response handler
+ * @returns a RateLimitedFetchHandler that rate-limits outgoing requests and retries on throttle responses
+ */ function rateLimitedFetchHandler(config) {
     var updateWithResponse = config.updateWithResponse, inputMaxRetries = config.maxRetries;
     var maxRetries = inputMaxRetries !== null && inputMaxRetries !== void 0 ? inputMaxRetries : 1;
     var _rateLimiter = config.rateLimiter;
@@ -1243,7 +1294,7 @@ function rateLimitedFetchHandler(config) {
         return _async_to_generator$2(function() {
             function tryFetch(retriesAttempted) {
                 return _async_to_generator$2(function() {
-                    var response, fetchResponseError, e, shouldRetry, _tmp;
+                    var response, fetchResponseError, e, shouldRetry;
                     return _ts_generator$2(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -1281,50 +1332,33 @@ function rateLimitedFetchHandler(config) {
                                     5
                                 ];
                             case 5:
-                                if (!response) return [
-                                    3,
-                                    7
-                                ];
                                 return [
                                     4,
                                     updateWithResponse(response, fetchResponseError)
                                 ];
                             case 6:
-                                _tmp = _state.sent();
-                                return [
-                                    3,
-                                    8
-                                ];
-                            case 7:
-                                _tmp = false;
-                                _state.label = 8;
-                            case 8:
-                                shouldRetry = _tmp;
+                                shouldRetry = _state.sent();
                                 if (!(shouldRetry && retriesAttempted < maxRetries)) return [
                                     3,
-                                    10
+                                    8
                                 ];
                                 return [
                                     4,
                                     tryFetch(retriesAttempted + 1)
                                 ];
-                            case 9:
+                            case 7:
                                 response = _state.sent();
                                 return [
                                     3,
-                                    11
+                                    9
                                 ];
-                            case 10:
+                            case 8:
                                 // re-throw the fetch response error if it exists and we cannot retry
                                 if (fetchResponseError != null) {
                                     throw fetchResponseError;
                                 }
-                                _state.label = 11;
-                            case 11:
-                                // if response is null at this point but fetchResponseError is not, rethrow the error
-                                if (response == null && fetchResponseError != null) {
-                                    throw fetchResponseError;
-                                }
+                                _state.label = 9;
+                            case 9:
                                 return [
                                     2,
                                     response
@@ -1697,7 +1731,7 @@ var FetchPageLimitReachedError = /*#__PURE__*/ function(FetchRequestFactoryError
     };
 }
 
-function _array_like_to_array$1(arr, len) {
+function _array_like_to_array$2(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
@@ -1809,15 +1843,15 @@ function _object_spread_props$1(target, source) {
     return target;
 }
 function _sliced_to_array$1(arr, i) {
-    return _array_with_holes$1(arr) || _iterable_to_array_limit$1(arr, i) || _unsupported_iterable_to_array$1(arr, i) || _non_iterable_rest$1();
+    return _array_with_holes$1(arr) || _iterable_to_array_limit$1(arr, i) || _unsupported_iterable_to_array$2(arr, i) || _non_iterable_rest$1();
 }
-function _unsupported_iterable_to_array$1(o, minLen) {
+function _unsupported_iterable_to_array$2(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$2(o, minLen);
     var n = Object.prototype.toString.call(o).slice(8, -1);
     if (n === "Object" && o.constructor) n = o.constructor.name;
     if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
 }
 function _ts_generator(thisArg, body) {
     var f, y, t, _ = {
@@ -1953,32 +1987,23 @@ function _ts_generator(thisArg, body) {
                 iterateFetchPagesByItems(_object_spread_props$1(_object_spread$1({}, config), {
                     iteratePageItems: function iteratePageItems(items, fetchPageResult, startIndex) {
                         return _async_to_generator(function() {
-                            var itemIndexPairs, performTasksResults;
+                            var itemIndexPairs;
                             return _ts_generator(this, function(_state) {
-                                switch(_state.label){
-                                    case 0:
-                                        itemIndexPairs = items.map(function(x, i) {
-                                            return [
-                                                x,
-                                                i + startIndex
-                                            ];
-                                        });
-                                        return [
-                                            4,
-                                            performAsyncTasks(itemIndexPairs, function(param) {
-                                                var _param = _sliced_to_array$1(param, 2), item = _param[0], i = _param[1];
-                                                return iterateEachPageItem(item, i, fetchPageResult);
-                                            }, _object_spread$1({
-                                                sequential: true
-                                            }, iteratePerformTasksConfig))
-                                        ];
-                                    case 1:
-                                        performTasksResults = _state.sent();
-                                        return [
-                                            2,
-                                            performTasksResults
-                                        ];
-                                }
+                                itemIndexPairs = items.map(function(x, i) {
+                                    return [
+                                        x,
+                                        i + startIndex
+                                    ];
+                                });
+                                return [
+                                    2,
+                                    performAsyncTasks(itemIndexPairs, function(param) {
+                                        var _param = _sliced_to_array$1(param, 2), item = _param[0], i = _param[1];
+                                        return iterateEachPageItem(item, i, fetchPageResult);
+                                    }, _object_spread$1({
+                                        sequential: true
+                                    }, iteratePerformTasksConfig))
+                                ];
                             });
                         })();
                     }
@@ -2185,12 +2210,37 @@ function iterateFetchPages(config) {
     })();
 }
 
+function _array_like_to_array$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$1(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array$1(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
 /**
  * Creates URLSearchParams from the input objects. The input objects are merged together.
  *
- * @param input
- * @param omitKeys
- * @returns
+ * @param input - one or more objects (or nullish values) whose key-value pairs become search parameters
+ * @param options - optional configuration for filtering, omitting keys, and space encoding
+ * @returns a URLSearchParams instance built from the merged and filtered input
  */ function makeUrlSearchParams(input, options) {
     var _ref = options !== null && options !== void 0 ? options : {}, omitKeys = _ref.omitKeys, filterValues = _ref.filterEmptyValues;
     var mergedInput = Array.isArray(input) ? mergeObjects(input) : input;
@@ -2221,6 +2271,9 @@ function iterateFetchPages(config) {
 }
 /**
  * Merges an array of MakeUrlSearchParamsOptions into a single MakeUrlSearchParamsOptions value.
+ *
+ * @param options - one or more options objects whose omitKeys sets are combined
+ * @returns a single MakeUrlSearchParamsOptions with the union of all omitKeys
  */ function mergeMakeUrlSearchParamsOptions(options) {
     var omitKeys = new Set();
     useIterableOrValue(options, function(x) {
@@ -2231,7 +2284,7 @@ function iterateFetchPages(config) {
         }
     });
     return {
-        omitKeys: omitKeys.size > 0 ? Array.from(omitKeys) : undefined
+        omitKeys: omitKeys.size > 0 ? _to_consumable_array(omitKeys) : undefined
     };
 }
 
@@ -2292,7 +2345,13 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Map" || n === "Set") return Array.from(n);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
-function fetchURL(input) {
+/**
+ * Resolves a FetchURLInput to a URL string. Handles plain strings, URL objects, and
+ * FetchURLConfiguration objects by appending query parameters when provided.
+ *
+ * @param input - a string, URL, or FetchURLConfiguration to resolve
+ * @returns the resolved URL as a string
+ */ function fetchURL(input) {
     var url;
     if (typeof input === 'string') {
         url = input;
@@ -2313,10 +2372,20 @@ function fetchURL(input) {
     }
     return url;
 }
-function isURL(input) {
+/**
+ * Type guard that checks whether the given value is a URL instance.
+ *
+ * @param input - the value to test
+ * @returns true if the input is a URL instance
+ */ function isURL(input) {
     return (typeof input === "undefined" ? "undefined" : _type_of$1(input)) === 'object' && _instanceof(input, URL);
 }
-function isURLSearchParams(input) {
+/**
+ * Type guard that checks whether the given value is a URLSearchParams instance.
+ *
+ * @param input - the value to test
+ * @returns true if the input is a URLSearchParams instance
+ */ function isURLSearchParams(input) {
     return (typeof input === "undefined" ? "undefined" : _type_of$1(input)) === 'object' && _instanceof(input, URLSearchParams);
 }
 /**
@@ -2344,7 +2413,13 @@ function isURLSearchParams(input) {
     });
     return paramTuples;
 }
-function queryParamsToSearchParams(input) {
+/**
+ * Converts a FetchURLQueryParamsInput value (URLSearchParams, string, iterable of tuples, or
+ * params object) into a URLSearchParams instance.
+ *
+ * @param input - the query parameters input to convert
+ * @returns a URLSearchParams instance representing the input
+ */ function queryParamsToSearchParams(input) {
     var result;
     if (isURLSearchParams(input)) {
         // by url search params
@@ -2359,22 +2434,24 @@ function queryParamsToSearchParams(input) {
     }
     return result;
 }
-function fetchURLSearchParamsObjectToURLSearchParams(input) {
+/**
+ * Converts a FetchURLSearchParamsObject (a plain key-value record) into a URLSearchParams instance,
+ * expanding array values into multiple entries for the same key and filtering out null/undefined values.
+ *
+ * @param input - the params object to convert
+ * @returns a URLSearchParams instance representing the input object
+ */ function fetchURLSearchParamsObjectToURLSearchParams(input) {
     var paramTuples = [];
     forEachKeyValue(input, {
         forEach: function forEach(tuple) {
             var _tuple = _sliced_to_array(tuple, 2), key = _tuple[0], values = _tuple[1];
-            // ignore null/undefined keys and values
-            if (key != null && values != null) {
-                var keyString = String(key);
+            var keyString = String(key);
+            if (values != null) {
                 useIterableOrValue(values, function(x) {
-                    // ignore null/undefined values
-                    if (x != null) {
-                        paramTuples.push([
-                            keyString,
-                            String(x)
-                        ]);
-                    }
+                    paramTuples.push([
+                        keyString,
+                        String(x)
+                    ]);
                 });
             }
         }
@@ -2558,11 +2635,15 @@ var JsonResponseParseError = /*#__PURE__*/ function(Error1) {
 var throwJsonResponseParseErrorFunction = function throwJsonResponseParseErrorFunction(response) {
     throw new JsonResponseParseError(response);
 };
-var returnNullHandleFetchJsonParseErrorFunction = function returnNullHandleFetchJsonParseErrorFunction(_) {
+var returnNullHandleFetchJsonParseErrorFunction = function returnNullHandleFetchJsonParseErrorFunction(_response) {
     return null;
 };
 /**
  * Creates a FetchJsonFunction from the input ConfiguredFetch.
+ *
+ * @param fetch - the configured fetch function to use for making HTTP requests
+ * @param inputConfig - optional configuration or error handler for JSON parsing; when a function is provided it is used as the parse error handler
+ * @returns a FetchJsonFunction that performs requests and parses JSON responses
  */ function fetchJsonFunction(fetch, inputConfig) {
     var _config_handleFetchJsonParseErrorFunction;
     var config;
@@ -2594,18 +2675,19 @@ var returnNullHandleFetchJsonParseErrorFunction = function returnNullHandleFetch
         });
     };
 }
-function fetchJsonRequestInitFunction() {
+/**
+ * Creates a {@link FetchJsonRequestInitFunction} that converts method/body inputs into a fully formed {@link RequestInit},
+ * applying the configured default method and optional input mapping.
+ *
+ * @param config - optional configuration specifying the default HTTP method and an input mapping function
+ * @returns a function that produces a {@link RequestInit} from a method string or {@link FetchJsonInput}
+ */ function fetchJsonRequestInitFunction() {
     var config = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
     var _config_defaultMethod = config.defaultMethod, defaultMethod = _config_defaultMethod === void 0 ? 'GET' : _config_defaultMethod, _config_mapFetchJsonInput = config.mapFetchJsonInput, mapFetchJsonInput = _config_mapFetchJsonInput === void 0 ? mapIdentityFunction() : _config_mapFetchJsonInput;
     return function() {
         var methodOrInput = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : defaultMethod, body = arguments.length > 1 ? arguments[1] : void 0;
-        var _config_method;
         var config;
-        if (methodOrInput === null) {
-            config = {
-                method: defaultMethod
-            };
-        } else if (typeof methodOrInput === 'string') {
+        if (typeof methodOrInput === 'string') {
             config = {
                 method: methodOrInput,
                 body: body
@@ -2615,7 +2697,7 @@ function fetchJsonRequestInitFunction() {
         }
         config = mapFetchJsonInput(config);
         var requestInit = _object_spread_props(_object_spread({}, config), {
-            method: (_config_method = config.method) !== null && _config_method !== void 0 ? _config_method : defaultMethod,
+            method: config.method,
             body: fetchJsonBodyString(config.body)
         });
         return requestInit;

package/fetch/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@dereekb/util/fetch",
-  "version": "13.3.1",
+  "version": "13.4.1",
   "peerDependencies": {
-    "@dereekb/util": "13.3.1",
+    "@dereekb/util": "13.4.1",
     "make-error": "^1.3.0",
     "fast-content-type-parse": "^3.0.0"
   },

package/fetch/src/lib/error.d.ts

@@ -17,4 +17,10 @@ export declare class FetchResponseError extends BaseError {
     readonly response: Response;
     constructor(response: Response);
 }
+/**
+ * Asserts that the fetch response has an ok status code, throwing a FetchResponseError if it does not.
+ *
+ * @param responsePromise - promise resolving to the fetch Response to validate
+ * @returns a promise resolving to the Response if the status is ok
+ */
 export declare function requireOkResponse(responsePromise: Promise<Response>): Promise<Response>;

package/fetch/src/lib/fetch.d.ts

@@ -51,6 +51,7 @@ export interface ConfigureFetchInput extends FetchRequestFactoryInput {
 }
 /**
  * Default FetchHabdler
+ *
  * @param request
  * @param makeFetch
  * @returns
@@ -110,8 +111,44 @@ export type AbortControllerFactory = Factory<AbortController>;
  * @returns
  */
 export declare const DEFAULT_FETCH_REQUEST_FACTORY: FetchRequestFactory;
+/**
+ * Creates a FetchRequestFactory that builds Request objects by applying base URL resolution,
+ * base request init merging, timeout configuration, and custom request init transformations.
+ *
+ * @param config - configuration for URL resolution, base request defaults, timeout, and request init transformations
+ * @returns a FetchRequestFactory that produces fully configured Request objects
+ */
 export declare function fetchRequestFactory(config: FetchRequestFactoryInput): FetchRequestFactory;
+/**
+ * Merges two RequestInit objects, combining their headers and spreading remaining properties
+ * so that values from the second init override the base.
+ *
+ * @param base - the base RequestInit to merge onto
+ * @param requestInit - optional RequestInit whose values override the base
+ * @returns the merged RequestInit
+ */
 export declare function mergeRequestInits<T extends RequestInit>(base: T, requestInit?: T | undefined): T;
+/**
+ * Merges an array of HeadersInit values into a single array of key-value tuples.
+ * Later headers override earlier ones on a per-key basis while preserving multi-value support.
+ *
+ * @param inputHeadersArray - array of HeadersInit values to merge, where later entries take precedence
+ * @returns an array of [key, value] tuples representing the merged headers
+ */
 export declare function mergeRequestHeaders(inputHeadersArray: Maybe<HeadersInit>[]): [string, string][];
+/**
+ * Converts a HeadersInit value (tuple array, Headers object, or plain object) into
+ * a normalized array of [key, value] tuples.
+ *
+ * @param headers - the HeadersInit value to convert
+ * @returns an array of [key, value] string tuples
+ */
 export declare function headersToHeadersTuple(headers: HeadersInit): [string, string][];
+/**
+ * Type guard that checks whether the given input is a fetch Request object
+ * by testing for the presence of a url property.
+ *
+ * @param input - the value to test
+ * @returns true if the input is a Request
+ */
 export declare function isFetchRequest(input: unknown): input is Request;