@blueprint-ts/core 4.1.0-beta.2 → 4.1.0-beta.3

package/src/requests/BaseRequest.ts

@@ -1,321 +0,0 @@
-import qs from 'qs'
-import { ErrorHandler } from './ErrorHandler'
-import { RequestEvents } from './RequestEvents.enum'
-import { RequestMethodEnum } from './RequestMethod.enum'
-import { BaseResponse } from './responses/BaseResponse'
-import { ResponseException } from './exceptions/ResponseException'
-import { StaleResponseException } from './exceptions/StaleResponseException'
-import { type DriverConfigContract } from './contracts/DriverConfigContract'
-import { type BodyFactoryContract } from './contracts/BodyFactoryContract'
-import { type BodyContract } from './contracts/BodyContract'
-import { type RequestLoaderContract } from './contracts/RequestLoaderContract'
-import { type RequestDriverContract } from './contracts/RequestDriverContract'
-import { type RequestLoaderFactoryContract } from './contracts/RequestLoaderFactoryContract'
-import { type BaseRequestContract, type EventHandlerCallback } from './contracts/BaseRequestContract'
-import { type HeadersContract } from './contracts/HeadersContract'
-import { type ResponseHandlerContract } from './drivers/contracts/ResponseHandlerContract'
-import { type ResponseContract } from './contracts/ResponseContract'
-import { type RequestConcurrencyOptions } from './types/RequestConcurrencyOptions'
-import { type RequestUploadProgress } from './types/RequestUploadProgress'
-import { RequestConcurrencyMode } from './RequestConcurrencyMode.enum'
-import { mergeDeep } from '../support/helpers'
-import { v4 as uuidv4 } from 'uuid'
-
-export abstract class BaseRequest<
-  RequestLoaderLoadingType,
-  ResponseErrorBody,
-  ResponseBodyInterface = undefined,
-  ResponseClass extends ResponseContract<ResponseBodyInterface> = BaseResponse<ResponseBodyInterface>,
-  RequestBodyInterface = undefined,
-  RequestParamsInterface extends object = object
-> implements BaseRequestContract<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface> {
-  protected requestId: string = uuidv4()
-  protected params: RequestParamsInterface | undefined = undefined
-  protected requestBody: RequestBodyInterface | undefined = undefined
-  protected requestLoader: RequestLoaderContract<RequestLoaderLoadingType> | undefined = undefined
-  protected abortSignal: AbortSignal | undefined = undefined
-  protected concurrencyOptions: RequestConcurrencyOptions | undefined = undefined
-  /* @ts-expect-error Ignore generics */
-  protected events: { [key in RequestEvents]?: EventHandlerCallback[] } = {}
-
-  protected static defaultBaseUrl: string
-
-  protected static requestDriver: RequestDriverContract
-  protected static requestLoaderFactory: RequestLoaderFactoryContract<unknown>
-  protected static concurrencySequenceByKey: Map<string, number> = new Map()
-  protected static concurrencyAbortControllerByKey: Map<string, AbortController> = new Map()
-  protected static concurrencyInFlightByKey: Map<string, number> = new Map()
-
-  public constructor() {
-    if (BaseRequest.requestLoaderFactory !== undefined) {
-      this.requestLoader = BaseRequest.requestLoaderFactory.make() as RequestLoaderContract<RequestLoaderLoadingType>
-    }
-  }
-
-  public static setRequestDriver(driver: RequestDriverContract) {
-    this.requestDriver = driver
-  }
-
-  public static setRequestLoaderFactory<T>(factory: RequestLoaderFactoryContract<T>): void {
-    this.requestLoaderFactory = factory
-  }
-
-  public static setDefaultBaseUrl(url: string) {
-    this.defaultBaseUrl = url
-  }
-
-  public setRequestLoader(loader: RequestLoaderContract<RequestLoaderLoadingType>): this {
-    this.requestLoader = loader
-
-    return this
-  }
-
-  public setConcurrency(options?: RequestConcurrencyOptions): this {
-    this.concurrencyOptions = options
-
-    return this
-  }
-
-  public getRequestId(): string {
-    return this.requestId
-  }
-
-  public abstract method(): RequestMethodEnum
-
-  public abstract url(): URL | string
-
-  public setParams(params?: RequestParamsInterface): this {
-    this.params = params
-
-    return this
-  }
-
-  public withParams(params: RequestParamsInterface): this {
-    this.params = this.params === undefined ? params : (mergeDeep({}, this.params, params) as RequestParamsInterface)
-
-    return this
-  }
-
-  public getParams(): RequestParamsInterface | undefined {
-    return this.params
-  }
-
-  public setBody(requestBody: RequestBodyInterface): this {
-    this.requestBody = requestBody
-
-    return this
-  }
-
-  public getBody(): RequestBodyInterface | undefined {
-    return this.requestBody
-  }
-
-  public requestHeaders(): HeadersContract {
-    return {}
-  }
-
-  public buildUrl(): URL {
-    const hasParams = this.params !== undefined && Object.keys(this.params).length > 0
-    const url = hasParams ? this.url() + '?' + qs.stringify(this.params) : this.url()
-
-    return new URL(url, this.baseUrl() ?? BaseRequest.defaultBaseUrl)
-  }
-
-  public on<T>(event: RequestEvents, handler: EventHandlerCallback<T>): this {
-    if (!this.events[event]) {
-      this.events[event] = []
-    }
-
-    this.events[event].push(handler)
-
-    return this
-  }
-
-  protected dispatch<T>(event: RequestEvents, value: T) {
-    if (!this.events[event]) {
-      return
-    }
-
-    this.events[event].forEach((handler: EventHandlerCallback<T>) => handler(value))
-  }
-
-  public async send(): Promise<ResponseClass> {
-    const concurrencyMode: RequestConcurrencyMode = this.concurrencyOptions?.mode ?? RequestConcurrencyMode.ALLOW
-    const concurrencyKey = this.concurrencyOptions?.key ?? this.requestId
-    const useReplace = concurrencyMode === RequestConcurrencyMode.REPLACE || concurrencyMode === RequestConcurrencyMode.REPLACE_LATEST
-    const useLatest = concurrencyMode === RequestConcurrencyMode.LATEST || concurrencyMode === RequestConcurrencyMode.REPLACE_LATEST
-    const sequence = this.bumpConcurrencySequence(concurrencyKey)
-    this.incrementConcurrencyInFlight(concurrencyKey)
-
-    if (useReplace) {
-      const previousController = BaseRequest.concurrencyAbortControllerByKey.get(concurrencyKey)
-
-      if (previousController) {
-        previousController.abort()
-      }
-
-      const controller = new AbortController()
-      BaseRequest.concurrencyAbortControllerByKey.set(concurrencyKey, controller)
-      this.setAbortSignal(controller.signal)
-    }
-
-    this.dispatch<boolean>(RequestEvents.LOADING, true)
-
-    this.requestLoader?.setLoading(true)
-
-    const responseSkeleton = this.getResponse()
-
-    const requestBody = this.requestBody === undefined ? undefined : this.getRequestBodyFactory()?.make(this.requestBody)
-    const requestConfig = this.buildRequestConfig(requestBody, concurrencyKey, sequence, useLatest)
-
-    return this.resolveRequestDriver()
-      .send(
-        this.buildUrl(),
-        this.method(),
-        {
-          Accept: responseSkeleton.getAcceptHeader(),
-          ...this.requestHeaders()
-        },
-        requestBody,
-        requestConfig
-      )
-      .then(async (responseHandler: ResponseHandlerContract) => {
-        if (useLatest && !this.isLatestSequence(concurrencyKey, sequence)) {
-          throw new StaleResponseException()
-        }
-
-        await responseSkeleton.setResponse(responseHandler)
-
-        return responseSkeleton
-      })
-      .catch(async (error) => {
-        if (useLatest && !this.isLatestSequence(concurrencyKey, sequence)) {
-          throw new StaleResponseException('Stale response ignored', error)
-        }
-
-        if (error instanceof StaleResponseException) {
-          throw error
-        }
-
-        if (error instanceof ResponseException) {
-          const handler = new ErrorHandler<ResponseErrorBody>(error.getResponse())
-
-          await handler.handle()
-        }
-
-        console.error('@blueprint-ts/core: Unknown error received.', error)
-
-        throw error
-      })
-      .finally(() => {
-        const isStale = useLatest && !this.isLatestSequence(concurrencyKey, sequence)
-
-        if (!isStale) {
-          this.dispatch<boolean>(RequestEvents.LOADING, false)
-          this.requestLoader?.setLoading(false)
-        }
-
-        this.decrementConcurrencyInFlight(concurrencyKey)
-      })
-  }
-
-  public isLoading(): RequestLoaderLoadingType {
-    if (!this.requestLoader) {
-      throw new Error('Request loader is not set.')
-    }
-
-    return this.requestLoader.isLoading()
-  }
-
-  public abstract getResponse(): ResponseClass
-
-  public getRequestBodyFactory(): BodyFactoryContract<RequestBodyInterface | undefined> | undefined {
-    return undefined
-  }
-
-  public setAbortSignal(signal: AbortSignal): this {
-    this.abortSignal = signal
-
-    return this
-  }
-
-  protected bumpConcurrencySequence(key: string): number {
-    const next = (BaseRequest.concurrencySequenceByKey.get(key) ?? 0) + 1
-    BaseRequest.concurrencySequenceByKey.set(key, next)
-
-    return next
-  }
-
-  protected isLatestSequence(key: string, sequence: number): boolean {
-    return (BaseRequest.concurrencySequenceByKey.get(key) ?? 0) === sequence
-  }
-
-  protected incrementConcurrencyInFlight(key: string): void {
-    const next = (BaseRequest.concurrencyInFlightByKey.get(key) ?? 0) + 1
-    BaseRequest.concurrencyInFlightByKey.set(key, next)
-  }
-
-  protected decrementConcurrencyInFlight(key: string): void {
-    const current = BaseRequest.concurrencyInFlightByKey.get(key)
-
-    if (current === undefined) {
-      return
-    }
-
-    const next = current - 1
-
-    if (next <= 0) {
-      BaseRequest.concurrencyInFlightByKey.delete(key)
-      BaseRequest.concurrencySequenceByKey.delete(key)
-      BaseRequest.concurrencyAbortControllerByKey.delete(key)
-      return
-    }
-
-    BaseRequest.concurrencyInFlightByKey.set(key, next)
-  }
-
-  protected baseUrl(): undefined {
-    return undefined
-  }
-
-  protected buildRequestConfig(
-    requestBody: BodyContract | undefined,
-    concurrencyKey: string,
-    sequence: number,
-    useLatest: boolean
-  ): DriverConfigContract {
-    const config = this.getConfig() ?? {}
-    const onUploadProgress = config.onUploadProgress
-
-    if (requestBody === undefined) {
-      return config
-    }
-
-    return {
-      ...config,
-      onUploadProgress: (progress: RequestUploadProgress) => {
-        onUploadProgress?.(progress)
-
-        if (useLatest && !this.isLatestSequence(concurrencyKey, sequence)) {
-          return
-        }
-
-        this.dispatch<RequestUploadProgress>(RequestEvents.UPLOAD_PROGRESS, progress)
-      }
-    }
-  }
-
-  protected getConfig(): DriverConfigContract | undefined {
-    return {
-      abortSignal: this.abortSignal
-    }
-  }
-
-  protected resolveRequestDriver(): RequestDriverContract {
-    return this.getRequestDriver() ?? BaseRequest.requestDriver
-  }
-
-  protected getRequestDriver(): RequestDriverContract | undefined {
-    return undefined
-  }
-}

package/src/requests/ErrorHandler.ts

@@ -1,144 +0,0 @@
-import { PageExpiredException } from './exceptions/PageExpiredException'
-import { NotFoundException } from './exceptions/NotFoundException'
-import { UnauthorizedException } from './exceptions/UnauthorizedException'
-import { ValidationException } from './exceptions/ValidationException'
-import { ResponseException } from './exceptions/ResponseException'
-import { NoResponseReceivedException } from './exceptions/NoResponseReceivedException'
-import { ServerErrorException } from './exceptions/ServerErrorException'
-import { type ResponseHandlerContract } from './drivers/contracts/ResponseHandlerContract'
-import { ForbiddenException } from './exceptions/ForbiddenException'
-import { TooManyRequestsException } from './exceptions/TooManyRequestsException'
-import { LockedException } from './exceptions/LockedException'
-import { NotImplementedException } from './exceptions/NotImplementedException'
-import { ServiceUnavailableException } from './exceptions/ServiceUnavailableException'
-import { MethodNotAllowedException } from './exceptions/MethodNotAllowedException'
-import { RequestTimeoutException } from './exceptions/RequestTimeoutException'
-import { ConflictException } from './exceptions/ConflictException'
-import { GoneException } from './exceptions/GoneException'
-import { PreconditionFailedException } from './exceptions/PreconditionFailedException'
-import { PayloadTooLargeException } from './exceptions/PayloadTooLargeException'
-import { UnsupportedMediaTypeException } from './exceptions/UnsupportedMediaTypeException'
-import { BadGatewayException } from './exceptions/BadGatewayException'
-import { GatewayTimeoutException } from './exceptions/GatewayTimeoutException'
-import { BadRequestException } from './exceptions/BadRequestException'
-import { InvalidJsonException } from './exceptions/InvalidJsonException'
-
-export type ErrorHandlerCallback = ((response: ResponseHandlerContract) => boolean | void) | undefined
-
-export class ErrorHandler<ResponseErrorBody> {
-  protected body: ResponseErrorBody | undefined = undefined
-  protected static handler: ErrorHandlerCallback = undefined
-
-  public constructor(protected response: ResponseHandlerContract) {}
-
-  public async handle() {
-    // Check if there is a global error handler set
-    if (ErrorHandler.handler !== undefined) {
-      // If handler returns false, we don't process the error further
-      if (ErrorHandler.handler(this.response) === false) {
-        console.debug('Skipping further error handling due to global handler returning false.')
-        return
-      }
-    }
-
-    try {
-      this.body = await this.response.json<ResponseErrorBody>()
-    } catch (error) {
-      throw new InvalidJsonException(this.response, error)
-    }
-
-    if (this.body === undefined) {
-      throw new NoResponseReceivedException(this.response)
-    }
-
-    this.handleResponseError(this.response, this.body)
-  }
-
-  public static registerHandler(callback: ErrorHandlerCallback) {
-    ErrorHandler.handler = callback
-  }
-
-  protected handleResponseError(response: ResponseHandlerContract, body: ResponseErrorBody) {
-    if (response.getStatusCode() === 400) {
-      throw new BadRequestException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 401) {
-      throw new UnauthorizedException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 403) {
-      throw new ForbiddenException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 404) {
-      throw new NotFoundException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 405) {
-      throw new MethodNotAllowedException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 408) {
-      throw new RequestTimeoutException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 409) {
-      throw new ConflictException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 410) {
-      throw new GoneException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 412) {
-      throw new PreconditionFailedException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 413) {
-      throw new PayloadTooLargeException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 415) {
-      throw new UnsupportedMediaTypeException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 419) {
-      throw new PageExpiredException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 422) {
-      throw new ValidationException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 423) {
-      throw new LockedException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 429) {
-      throw new TooManyRequestsException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 500) {
-      throw new ServerErrorException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 501) {
-      throw new NotImplementedException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 502) {
-      throw new BadGatewayException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 503) {
-      throw new ServiceUnavailableException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 504) {
-      throw new GatewayTimeoutException<ResponseErrorBody>(response, body)
-    }
-
-    throw new ResponseException(response)
-  }
-}

package/src/requests/RequestConcurrencyMode.enum.ts

@@ -1,6 +0,0 @@
-export enum RequestConcurrencyMode {
-  ALLOW = 'allow',
-  REPLACE = 'replace',
-  LATEST = 'latest',
-  REPLACE_LATEST = 'replace-latest'
-}

package/src/requests/RequestErrorRouter.ts

@@ -1,89 +0,0 @@
-import { BadRequestException } from './exceptions/BadRequestException'
-import { MethodNotAllowedException } from './exceptions/MethodNotAllowedException'
-import { RequestTimeoutException } from './exceptions/RequestTimeoutException'
-import { ConflictException } from './exceptions/ConflictException'
-import { GoneException } from './exceptions/GoneException'
-import { PreconditionFailedException } from './exceptions/PreconditionFailedException'
-import { PayloadTooLargeException } from './exceptions/PayloadTooLargeException'
-import { UnsupportedMediaTypeException } from './exceptions/UnsupportedMediaTypeException'
-import { ForbiddenException } from './exceptions/ForbiddenException'
-import { LockedException } from './exceptions/LockedException'
-import { NoResponseReceivedException } from './exceptions/NoResponseReceivedException'
-import { NotFoundException } from './exceptions/NotFoundException'
-import { NotImplementedException } from './exceptions/NotImplementedException'
-import { BadGatewayException } from './exceptions/BadGatewayException'
-import { PageExpiredException } from './exceptions/PageExpiredException'
-import { ResponseBodyException } from './exceptions/ResponseBodyException'
-import { ResponseException } from './exceptions/ResponseException'
-import { ServerErrorException } from './exceptions/ServerErrorException'
-import { ServiceUnavailableException } from './exceptions/ServiceUnavailableException'
-import { GatewayTimeoutException } from './exceptions/GatewayTimeoutException'
-import { TooManyRequestsException } from './exceptions/TooManyRequestsException'
-import { UnauthorizedException } from './exceptions/UnauthorizedException'
-import { ValidationException } from './exceptions/ValidationException'
-import { InvalidJsonException } from './exceptions/InvalidJsonException'
-
-type RequestExceptionConstructor =
-  | typeof BadRequestException
-  | typeof MethodNotAllowedException
-  | typeof RequestTimeoutException
-  | typeof ConflictException
-  | typeof GoneException
-  | typeof PreconditionFailedException
-  | typeof PayloadTooLargeException
-  | typeof UnsupportedMediaTypeException
-  | typeof UnauthorizedException
-  | typeof ForbiddenException
-  | typeof NotFoundException
-  | typeof PageExpiredException
-  | typeof ValidationException
-  | typeof LockedException
-  | typeof TooManyRequestsException
-  | typeof ServerErrorException
-  | typeof NotImplementedException
-  | typeof BadGatewayException
-  | typeof ServiceUnavailableException
-  | typeof GatewayTimeoutException
-  | typeof NoResponseReceivedException
-  | typeof InvalidJsonException
-  | typeof ResponseBodyException
-  | typeof ResponseException
-
-type ErrorHandlerCallback<T extends Error> = (error: T) => void | Promise<void>
-
-type UnknownErrorHandlerCallback = (error: unknown) => void | Promise<void>
-
-export class RequestErrorRouter {
-  protected handlers: Array<{ ctor: RequestExceptionConstructor; handler: ErrorHandlerCallback<Error> }> = []
-  protected defaultHandler: UnknownErrorHandlerCallback | undefined = undefined
-
-  public on<C extends RequestExceptionConstructor>(ctor: C, handler: ErrorHandlerCallback<InstanceType<C>>): this {
-    this.handlers.push({ ctor, handler: handler as ErrorHandlerCallback<Error> })
-
-    return this
-  }
-
-  public otherwise(handler: UnknownErrorHandlerCallback): this {
-    this.defaultHandler = handler
-
-    return this
-  }
-
-  public async handle(error: unknown): Promise<boolean> {
-    for (const entry of this.handlers) {
-      if (error instanceof entry.ctor) {
-        await entry.handler(error)
-
-        return true
-      }
-    }
-
-    if (this.defaultHandler !== undefined) {
-      await this.defaultHandler(error)
-
-      return true
-    }
-
-    return false
-  }
-}

package/src/requests/RequestEvents.enum.ts

@@ -1,4 +0,0 @@
-export enum RequestEvents {
-  LOADING = 'loading',
-  UPLOAD_PROGRESS = 'upload-progress'
-}

package/src/requests/RequestMethod.enum.ts

@@ -1,8 +0,0 @@
-export enum RequestMethodEnum {
-  GET = 'GET',
-  HEAD = 'HEAD',
-  PATCH = 'PATCH',
-  POST = 'POST',
-  PUT = 'PUT',
-  DELETE = 'DELETE'
-}

package/src/requests/bodies/BinaryBody.ts

@@ -1,31 +0,0 @@
-import { type BodyContent, type BodyContract } from '../contracts/BodyContract'
-import { type HeadersContract } from '../contracts/HeadersContract'
-
-export class BinaryBody<RequestBody extends Exclude<BodyContent, string | FormData>> implements BodyContract {
-  public constructor(
-    protected data: RequestBody,
-    protected contentType?: string
-  ) {}
-
-  public getHeaders(): HeadersContract {
-    const contentType = this.resolveContentType()
-
-    return contentType === undefined ? {} : { 'Content-Type': contentType }
-  }
-
-  public getContent(): RequestBody {
-    return this.data
-  }
-
-  protected resolveContentType(): string | undefined {
-    if (this.contentType !== undefined) {
-      return this.contentType
-    }
-
-    if (typeof Blob !== 'undefined' && this.data instanceof Blob && this.data.type !== '') {
-      return this.data.type
-    }
-
-    return undefined
-  }
-}

package/src/requests/bodies/FormDataBody.ts

@@ -1,81 +0,0 @@
-import { type BodyContract } from '../contracts/BodyContract'
-import { type HeadersContract } from '../contracts/HeadersContract'
-import { isObject } from '../../support/helpers'
-
-type FormDataPrimitive = string | number | boolean | null | Date | Blob
-type FormDataValue = FormDataPrimitive | FormDataValue[] | { [key: string]: FormDataValue }
-
-export class FormDataBody<RequestBody extends Record<string, FormDataValue | undefined>> implements BodyContract {
-  protected data: FormData
-
-  public constructor(data: RequestBody) {
-    this.data = this.toFormData(data)
-  }
-
-  public getContent(): FormData {
-    return this.data
-  }
-
-  public getHeaders(): HeadersContract {
-    return {}
-  }
-
-  protected toFormData(data: Record<string, FormDataValue | undefined>, form: FormData = new FormData(), namespace: string | null = null): FormData {
-    for (const property in data) {
-      if (Object.prototype.hasOwnProperty.call(data, property)) {
-        const formKey = namespace ? namespace + '[' + property + ']' : property
-
-        const value = data[property]
-
-        // Null is a valid "explicitly empty" value in many APIs.
-        // In multipart FormData we encode it as an empty string so the key is still present.
-        if (value === null) {
-          form.append(formKey, '')
-          continue
-        }
-
-        // Undefined values should not reach the request layer (BaseForm omits them).
-        // Reject explicitly to avoid silently dropping keys.
-        if (value === undefined) {
-          throw new Error('Unexpected value')
-        }
-
-        if (value instanceof Date) {
-          form.append(formKey, value.toISOString())
-          continue
-        }
-
-        // Support arrays via bracket notation: key[0], key[1], ...
-        if (Array.isArray(value)) {
-          for (let i = 0; i < value.length; i++) {
-            const indexed: Record<string, FormDataValue | undefined> = { [String(i)]: value[i] }
-            this.toFormData(indexed, form, formKey)
-          }
-          continue
-        }
-
-        // Files/Blobs should be appended directly (File extends Blob)
-        if (typeof Blob !== 'undefined' && value instanceof Blob) {
-          form.append(formKey, value)
-          continue
-        }
-
-        // if the property is an object, use recursivity.
-        if (isObject(value)) {
-          this.toFormData(value as Record<string, FormDataValue | undefined>, form, formKey)
-          continue
-        }
-
-        // Primitives: append as strings
-        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-          form.append(formKey, String(value))
-          continue
-        }
-
-        throw new Error('Unexpected value')
-      }
-    }
-
-    return form
-  }
-}