🎨 Golf bytes

Author: elbywan

src/addons/progress.ts

@@ -87,9 +87,7 @@ function toStream<T extends Request | Response>(requestOrResponse: T, callback:
         if (total < loaded) {
           total = loaded
         }
-        if (callback) {
-          callback?.(loaded, total)
-        }
+        callback?.(loaded, total)
         controller.enqueue(chunk)
       }
     })

src/addons/queryString.ts

@@ -1,9 +1,5 @@
 import type { Wretch, WretchAddon } from "../types.js"
 
-function stringify(value?: string | null): string | null {
-  return typeof value !== "undefined" ? value : ""
-}
-
 /**
  * Options for the query method.
  */
@@ -28,11 +24,11 @@ const appendQueryParams = (url: string, qp: object | string, replace: boolean, o
     for (const key in qp) {
       const value = qp[key]
       if (omitUndefinedOrNullValues && (value === null || value === undefined)) continue
-      if (qp[key] instanceof Array) {
+      if (Array.isArray(value)) {
         for (const val of value)
-          usp.append(key, stringify(val))
+          usp.append(key, val ?? "")
       } else {
-        usp.append(key, stringify(value))
+        usp.append(key, value ?? "")
       }
     }
     queryString = usp.toString()

src/constants.ts

@@ -1,4 +1,3 @@
 export const JSON_MIME = "application/json"
-export const CONTENT_TYPE_HEADER = "Content-Type"
 export const FETCH_ERROR = Symbol()
 export const CATCHER_FALLBACK = Symbol()

src/core.ts

@@ -1,5 +1,5 @@
 import { mix, extractContentType, isLikelyJsonMime } from "./utils.js"
-import { JSON_MIME, CONTENT_TYPE_HEADER, CATCHER_FALLBACK } from "./constants.js"
+import { JSON_MIME, CATCHER_FALLBACK } from "./constants.js"
 import { resolver } from "./resolver.js"
 import type { Wretch } from "./types.js"
 
@@ -20,11 +20,11 @@ export const core: Wretch = {
   url(_url, replace = false) {
     if (replace)
       return { ...this, _url }
-    const split = this._url.split("?")
+    const idx = this._url.indexOf("?")
     return {
       ...this,
-      _url: split.length > 1 ?
-        split[0] + _url + "?" + split[1] :
+      _url: idx > -1 ?
+        this._url.slice(0, idx) + _url + this._url.slice(idx) :
         this._url + _url
     }
   },
@@ -43,7 +43,7 @@ export const core: Wretch = {
     return this.headers({ Accept: headerValue })
   },
   content(headerValue) {
-    return this.headers({ [CONTENT_TYPE_HEADER]: headerValue })
+    return this.headers({ "Content-Type": headerValue })
   },
   auth(headerValue) {
     return this.headers({ Authorization: headerValue })

src/index.all.ts

@@ -2,16 +2,15 @@ import { core } from "./core.js"
 import * as Addons from "./addons/index.js"
 import { WretchError } from "./resolver.js"
 
-function factory(_url = "", _options = {}) {
-  return { ...core, _url, _options }
+const factory = (_url = "", _options = {}) =>
+  ({ ...core, _url, _options })
     .addon(Addons.abortAddon())
     .addon(Addons.basicAuthAddon)
     .addon(Addons.formDataAddon)
     .addon(Addons.formUrlAddon)
     .addon(Addons.perfsAddon())
     .addon(Addons.queryStringAddon)
     .addon(Addons.progressAddon())
-}
 
 factory["default"] = factory
 factory.WretchError = WretchError

src/index.ts

@@ -31,9 +31,8 @@ export type {
  * @param _options The base fetch options
  * @returns A fresh wretch instance
  */
-function factory(_url = "", _options: WretchOptions = {}): Wretch {
-  return { ...core, _url, _options }
-}
+const factory = (_url = "", _options: WretchOptions = {}): Wretch =>
+  ({ ...core, _url, _options })
 
 factory["default"] = factory
 factory.WretchError = WretchError

src/middleware.ts

@@ -3,6 +3,5 @@ import type { ConfiguredMiddleware, FetchLike } from "./types.js"
 /**
  * @private @internal
  */
-export const middlewareHelper = (middlewares: ConfiguredMiddleware[]) => (fetchFunction: FetchLike): FetchLike => {
-  return middlewares.reduceRight((acc, curr) => curr(acc), fetchFunction) || fetchFunction
-}
+export const middlewareHelper = (middlewares: ConfiguredMiddleware[]) => (fetchFunction: FetchLike): FetchLike =>
+  middlewares.reduceRight((acc, curr) => curr(acc), fetchFunction)

src/resolver.ts

@@ -52,7 +52,7 @@ export const resolver = <T, Chain, R, E>(wretch: T & Wretch<T, Chain, R, E>) =>
       if (!response.ok) {
         const err = new WretchError()
         err["cause"] = referenceError
-        err.stack = err.stack + "\nCAUSE: " + referenceError.stack
+        err.stack += "\nCAUSE: " + referenceError.stack
         err.response = response
         err.status = response.status
         err.url = finalUrl
@@ -77,34 +77,35 @@ export const resolver = <T, Chain, R, E>(wretch: T & Wretch<T, Chain, R, E>) =>
       return response
     })
   // Wraps the Promise in order to dispatch the error to a matching catcher
-  const catchersWrapper = <T>(promise: Promise<T>): Promise<void | T> => {
-    return promise.catch(err => {
-      const fetchErrorFlag = Object.prototype.hasOwnProperty.call(err, FETCH_ERROR)
+  const catchersWrapper = <T>(promise: Promise<T>): Promise<void | T> =>
+    promise.catch(err => {
+      const fetchErrorFlag = FETCH_ERROR in err
       const error = fetchErrorFlag ? err[FETCH_ERROR] : err
 
       const catcher =
         (error?.status && catchers.get(error.status)) ||
-        catchers.get(error?.name) || (
-          fetchErrorFlag && catchers.has(FETCH_ERROR) && catchers.get(FETCH_ERROR)
-        )
+        catchers.get(error?.name) ||
+        (fetchErrorFlag && catchers.get(FETCH_ERROR)) ||
+        catchers.get(CATCHER_FALLBACK)
 
       if (catcher)
         return catcher(error, wretch)
 
-      const catcherFallback = catchers.get(CATCHER_FALLBACK)
-      if (catcherFallback)
-        return catcherFallback(error, wretch)
-
       throw error
     })
-  }
   // Enforces the proper promise type when a body parsing method is called.
-  type BodyParser = <Type>(funName: "json" | "blob" | "formData" | "arrayBuffer" | "text" | null) => <Result = void>(cb?: (type: Type) => Result) => Promise<Awaited<Result>>
-  const bodyParser: BodyParser = funName => cb => funName ?
+  type BodyParser =
+    <Type>(funName: "json" | "blob" | "formData" | "arrayBuffer" | "text" | null)
+    => <Result = void>(cb?: (type: Type) => Result)
+    => Promise<Awaited<Result>>
+  const bodyParser: BodyParser = funName => cb => {
+    const promise = funName ?
     // If a callback is provided, then callback with the body result otherwise return the parsed body itself.
-    catchersWrapper(throwingPromise.then(_ => _ && _[funName]()).then(_ => cb ? cb(_) : _)) :
+      throwingPromise.then(_ => _?.[funName]()) :
     // No body parsing method - return the response
-    catchersWrapper(throwingPromise.then(_ => cb ? cb(_ as any) : _))
+      throwingPromise
+    return catchersWrapper(cb ? promise.then(cb) : promise)
+  }
 
   const responseChain: WretchResponseChain<T, Chain, R, E> = {
     _wretchReq: wretch,

src/utils.ts

@@ -1,27 +1,25 @@
-import { CONTENT_TYPE_HEADER } from "./constants.js"
-
 export function extractContentType(headers: HeadersInit = {}): string | undefined {
   const normalizedHeaders = headers instanceof Array ? Object.fromEntries(headers) : headers
-  return Object.entries(normalizedHeaders).find(([k]) =>
-    k.toLowerCase() === CONTENT_TYPE_HEADER.toLowerCase()
-  )?.[1]
+  for (const k in normalizedHeaders) {
+    if (k.toLowerCase() === "content-type") return normalizedHeaders[k]
+  }
 }
 
 export function isLikelyJsonMime(value: string): boolean {
-  return /^application\/.*json.*/.test(value)
+  return /^application\/.*json/.test(value)
 }
 
-export const mix = function (one: object, two: object, mergeArrays: boolean = false) {
-  return Object.entries(two).reduce((acc, [key, newValue]) => {
+export const mix = (one: object, two: object, mergeArrays = false) => {
+  const acc = { ...one }
+  for (const key in two) {
+    if (!Object.prototype.hasOwnProperty.call(two, key)) continue
     const value = one[key]
-    if (Array.isArray(value) && Array.isArray(newValue)) {
-      acc[key] = mergeArrays ? [...value, ...newValue] : newValue
-    } else if (typeof value === "object" && typeof newValue === "object") {
-      acc[key] = mix(value, newValue, mergeArrays)
-    } else {
-      acc[key] = newValue
-    }
-
-    return acc
-  }, { ...one })
+    const newValue = two[key]
+    acc[key] = Array.isArray(value) && Array.isArray(newValue) ?
+      mergeArrays ? [...value, ...newValue] : newValue :
+      typeof value === "object" && typeof newValue === "object" ?
+        mix(value, newValue, mergeArrays) :
+        newValue
+  }
+  return acc
 }