@blueprint-ts/core 1.1.0 → 1.1.2

package/src/service/requests/ErrorHandler.ts

@@ -1,64 +1,64 @@
-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'
-
-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) {
-    // 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(response) === false) {
-        console.debug('Skipping further error handling due to global handler returning false.')
-        return
-      }
-    }
-  }
-
-  public async handle() {
-    this.body = await this.response.json<ResponseErrorBody>()
-
-    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() === 401) {
-      throw new UnauthorizedException<ResponseErrorBody>(response, body)
-    }
-
-    if (response.getStatusCode() === 404) {
-      throw new NotFoundException<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() === 500) {
-      throw new ServerErrorException<ResponseErrorBody>(response, body)
-    }
-
-    throw new ResponseException(response)
-  }
-}
+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'
+
+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) {
+    // 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(response) === false) {
+        console.debug('Skipping further error handling due to global handler returning false.')
+        return
+      }
+    }
+  }
+
+  public async handle() {
+    this.body = await this.response.json<ResponseErrorBody>()
+
+    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() === 401) {
+      throw new UnauthorizedException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 404) {
+      throw new NotFoundException<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() === 500) {
+      throw new ServerErrorException<ResponseErrorBody>(response, body)
+    }
+
+    throw new ResponseException(response)
+  }
+}

package/src/service/requests/contracts/RequestDriverContract.ts

@@ -1,15 +1,15 @@
-import { RequestMethodEnum } from '../RequestMethod.enum'
-import { type HeadersContract } from './HeadersContract'
-import { type BodyContract } from './BodyContract'
-import { type ResponseHandlerContract } from '../drivers/contracts/ResponseHandlerContract'
-import { type DriverConfigContract } from './DriverConfigContract'
-
-export interface RequestDriverContract {
-  send(
-    url: URL | string,
-    method: RequestMethodEnum,
-    headers: HeadersContract,
-    body?: BodyContract,
-    requestConfig?: DriverConfigContract
-  ): Promise<ResponseHandlerContract>
-}
+import { RequestMethodEnum } from '../RequestMethod.enum'
+import { type HeadersContract } from './HeadersContract'
+import { type BodyContract } from './BodyContract'
+import { type ResponseHandlerContract } from '../drivers/contracts/ResponseHandlerContract'
+import { type DriverConfigContract } from './DriverConfigContract'
+
+export interface RequestDriverContract {
+  send(
+    url: URL | string,
+    method: RequestMethodEnum,
+    headers: HeadersContract,
+    body?: BodyContract,
+    requestConfig?: DriverConfigContract
+  ): Promise<ResponseHandlerContract>
+}

package/src/service/requests/exceptions/NoResponseReceivedException.ts

@@ -1,3 +1,3 @@
-import { ResponseException } from './ResponseException'
-
-export class NoResponseReceivedException extends ResponseException {}
+import { ResponseException } from './ResponseException'
+
+export class NoResponseReceivedException extends ResponseException {}

package/src/service/requests/exceptions/NotFoundException.ts

@@ -1,3 +1,3 @@
-import { ResponseBodyException } from './ResponseBodyException'
-
-export class NotFoundException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class NotFoundException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/service/requests/exceptions/PageExpiredException.ts

@@ -1,3 +1,3 @@
-import { ResponseBodyException } from './ResponseBodyException'
-
-export class PageExpiredException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class PageExpiredException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/service/requests/exceptions/ServerErrorException.ts

@@ -1,3 +1,3 @@
-import { ResponseBodyException } from './ResponseBodyException'
-
-export class ServerErrorException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class ServerErrorException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/service/requests/exceptions/UnauthorizedException.ts

@@ -1,3 +1,3 @@
-import { ResponseBodyException } from './ResponseBodyException'
-
-export class UnauthorizedException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class UnauthorizedException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/service/requests/exceptions/ValidationException.ts

@@ -1,3 +1,3 @@
-import { ResponseBodyException } from './ResponseBodyException'
-
-export class ValidationException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class ValidationException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/service/requests/exceptions/index.ts

@@ -1,19 +1,19 @@
-import { ValidationException } from './ValidationException'
-import { NotFoundException } from './NotFoundException'
-import { NoResponseReceivedException } from './NoResponseReceivedException'
-import { UnauthorizedException } from './UnauthorizedException'
-import { PageExpiredException } from './PageExpiredException'
-import { ServerErrorException } from './ServerErrorException'
-import { ResponseException } from './ResponseException'
-import { ResponseBodyException } from './ResponseBodyException'
-
-export {
-  ValidationException,
-  NotFoundException,
-  NoResponseReceivedException,
-  UnauthorizedException,
-  PageExpiredException,
-  ServerErrorException,
-  ResponseException,
-  ResponseBodyException
-}
+import { ValidationException } from './ValidationException'
+import { NotFoundException } from './NotFoundException'
+import { NoResponseReceivedException } from './NoResponseReceivedException'
+import { UnauthorizedException } from './UnauthorizedException'
+import { PageExpiredException } from './PageExpiredException'
+import { ServerErrorException } from './ServerErrorException'
+import { ResponseException } from './ResponseException'
+import { ResponseBodyException } from './ResponseBodyException'
+
+export {
+  ValidationException,
+  NotFoundException,
+  NoResponseReceivedException,
+  UnauthorizedException,
+  PageExpiredException,
+  ServerErrorException,
+  ResponseException,
+  ResponseBodyException
+}

package/src/service/requests/index.ts

@@ -1,50 +1,50 @@
-import { FetchDriver } from './drivers/fetch/FetchDriver'
-import { BaseResponse } from './responses/BaseResponse'
-import { JsonResponse } from './responses/JsonResponse'
-import { PlainTextResponse } from './responses/PlainTextResponse'
-import { BlobResponse } from './responses/BlobResponse'
-import { BaseRequest } from './BaseRequest'
-import { ErrorHandler } from './ErrorHandler'
-import { RequestEvents } from './RequestEvents.enum'
-import { RequestMethodEnum } from './RequestMethod.enum'
-import { JsonBodyFactory } from './factories/JsonBodyFactory'
-import { FormDataFactory } from './factories/FormDataFactory'
-import { type BodyContract } from './contracts/BodyContract'
-import { type RequestLoaderContract } from './contracts/RequestLoaderContract'
-import { type RequestDriverContract } from './contracts/RequestDriverContract'
-import { type PaginationParamsContract } from '../laravel/pagination/contracts/PaginationParamsContract'
-import { type RequestLoaderFactoryContract } from './contracts/RequestLoaderFactoryContract'
-import { type DriverConfigContract } from './contracts/DriverConfigContract'
-import { type BodyFactoryContract } from './contracts/BodyFactoryContract'
-import { type ResponseHandlerContract } from './drivers/contracts/ResponseHandlerContract'
-import { type BaseRequestContract } from './contracts/BaseRequestContract'
-import { ResponseException } from './exceptions/ResponseException'
-import { type HeadersContract } from './contracts/HeadersContract'
-
-export {
-  FetchDriver,
-  BaseResponse,
-  JsonResponse,
-  BlobResponse,
-  PlainTextResponse,
-  BaseRequest,
-  ErrorHandler,
-  RequestEvents,
-  RequestMethodEnum,
-  ResponseException,
-  JsonBodyFactory,
-  FormDataFactory
-}
-
-export type {
-  PaginationParamsContract,
-  RequestDriverContract,
-  RequestLoaderContract,
-  BodyContract,
-  RequestLoaderFactoryContract,
-  DriverConfigContract,
-  BodyFactoryContract,
-  ResponseHandlerContract,
-  BaseRequestContract,
-  HeadersContract
-}
+import { FetchDriver } from './drivers/fetch/FetchDriver'
+import { BaseResponse } from './responses/BaseResponse'
+import { JsonResponse } from './responses/JsonResponse'
+import { PlainTextResponse } from './responses/PlainTextResponse'
+import { BlobResponse } from './responses/BlobResponse'
+import { BaseRequest } from './BaseRequest'
+import { ErrorHandler } from './ErrorHandler'
+import { RequestEvents } from './RequestEvents.enum'
+import { RequestMethodEnum } from './RequestMethod.enum'
+import { JsonBodyFactory } from './factories/JsonBodyFactory'
+import { FormDataFactory } from './factories/FormDataFactory'
+import { type BodyContract } from './contracts/BodyContract'
+import { type RequestLoaderContract } from './contracts/RequestLoaderContract'
+import { type RequestDriverContract } from './contracts/RequestDriverContract'
+import { type PaginationParamsContract } from '../laravel/pagination/contracts/PaginationParamsContract'
+import { type RequestLoaderFactoryContract } from './contracts/RequestLoaderFactoryContract'
+import { type DriverConfigContract } from './contracts/DriverConfigContract'
+import { type BodyFactoryContract } from './contracts/BodyFactoryContract'
+import { type ResponseHandlerContract } from './drivers/contracts/ResponseHandlerContract'
+import { type BaseRequestContract } from './contracts/BaseRequestContract'
+import { ResponseException } from './exceptions/ResponseException'
+import { type HeadersContract } from './contracts/HeadersContract'
+
+export {
+  FetchDriver,
+  BaseResponse,
+  JsonResponse,
+  BlobResponse,
+  PlainTextResponse,
+  BaseRequest,
+  ErrorHandler,
+  RequestEvents,
+  RequestMethodEnum,
+  ResponseException,
+  JsonBodyFactory,
+  FormDataFactory
+}
+
+export type {
+  PaginationParamsContract,
+  RequestDriverContract,
+  RequestLoaderContract,
+  BodyContract,
+  RequestLoaderFactoryContract,
+  DriverConfigContract,
+  BodyFactoryContract,
+  ResponseHandlerContract,
+  BaseRequestContract,
+  HeadersContract
+}

package/src/service/requests/responses/BlobResponse.ts

@@ -1,19 +1,19 @@
-import { BaseResponse } from './BaseResponse'
-
-export class BlobResponse extends BaseResponse<Blob> {
-  public constructor(protected mimeType: string = 'application/octet-stream') {
-    super()
-  }
-
-  public getAcceptHeader(): string {
-    return this.mimeType
-  }
-
-  protected resolveBody(): Promise<Blob> {
-    if (!this.response) {
-      throw new Error('Response is not set')
-    }
-
-    return this.response.blob()
-  }
-}
+import { BaseResponse } from './BaseResponse'
+
+export class BlobResponse extends BaseResponse<Blob> {
+  public constructor(protected mimeType: string = 'application/octet-stream') {
+    super()
+  }
+
+  public getAcceptHeader(): string {
+    return this.mimeType
+  }
+
+  protected resolveBody(): Promise<Blob> {
+    if (!this.response) {
+      throw new Error('Response is not set')
+    }
+
+    return this.response.blob()
+  }
+}

package/src/service/requests/responses/JsonResponse.ts

@@ -1,15 +1,15 @@
-import { BaseResponse } from './BaseResponse'
-
-export class JsonResponse<ResponseBodyInterface> extends BaseResponse<ResponseBodyInterface> {
-  public getAcceptHeader(): string {
-    return 'application/json'
-  }
-
-  protected resolveBody(): Promise<ResponseBodyInterface> {
-    if (!this.response) {
-      throw new Error('Response is not set')
-    }
-
-    return this.response.json<ResponseBodyInterface>()
-  }
-}
+import { BaseResponse } from './BaseResponse'
+
+export class JsonResponse<ResponseBodyInterface> extends BaseResponse<ResponseBodyInterface> {
+  public getAcceptHeader(): string {
+    return 'application/json'
+  }
+
+  protected resolveBody(): Promise<ResponseBodyInterface> {
+    if (!this.response) {
+      throw new Error('Response is not set')
+    }
+
+    return this.response.json<ResponseBodyInterface>()
+  }
+}

package/src/service/requests/responses/PlainTextResponse.ts

@@ -1,15 +1,15 @@
-import { BaseResponse } from './BaseResponse'
-
-export class PlainTextResponse extends BaseResponse<string> {
-  public getAcceptHeader(): string {
-    return 'text/plain'
-  }
-
-  protected resolveBody(): Promise<string> {
-    if (!this.response) {
-      throw new Error('Response is not set')
-    }
-
-    return this.response.text()
-  }
-}
+import { BaseResponse } from './BaseResponse'
+
+export class PlainTextResponse extends BaseResponse<string> {
+  public getAcceptHeader(): string {
+    return 'text/plain'
+  }
+
+  protected resolveBody(): Promise<string> {
+    if (!this.response) {
+      throw new Error('Response is not set')
+    }
+
+    return this.response.text()
+  }
+}

package/src/vue/composables/useIsOpen.ts

@@ -1,37 +1,37 @@
-import { ref, computed, type Ref, type WritableComputedRef } from 'vue'
-
-export default function (
-  callback: (value: boolean) => void = () => {},
-  delay: number = 500
-): {
-  isOpenKey: Ref<number>
-  isOpen: WritableComputedRef<boolean>
-} {
-  const internalIsOpen = ref<boolean>(false)
-
-  const isOpenKey = ref<number>(0)
-
-  const isOpen = computed({
-    get(): boolean {
-      return internalIsOpen.value
-    },
-    set(value: boolean): void {
-      // False means we close, so we increment the key
-      // Add delay to preserve the closing animation.
-      setTimeout(() => {
-        if (!value) {
-          isOpenKey.value++
-        }
-      }, delay)
-
-      internalIsOpen.value = value
-
-      callback(value)
-    }
-  })
-
-  return {
-    isOpenKey,
-    isOpen
-  }
-}
+import { ref, computed, type Ref, type WritableComputedRef } from 'vue'
+
+export default function (
+  callback: (value: boolean) => void = () => {},
+  delay: number = 500
+): {
+  isOpenKey: Ref<number>
+  isOpen: WritableComputedRef<boolean>
+} {
+  const internalIsOpen = ref<boolean>(false)
+
+  const isOpenKey = ref<number>(0)
+
+  const isOpen = computed({
+    get(): boolean {
+      return internalIsOpen.value
+    },
+    set(value: boolean): void {
+      // False means we close, so we increment the key
+      // Add delay to preserve the closing animation.
+      setTimeout(() => {
+        if (!value) {
+          isOpenKey.value++
+        }
+      }, delay)
+
+      internalIsOpen.value = value
+
+      callback(value)
+    }
+  })
+
+  return {
+    isOpenKey,
+    isOpen
+  }
+}

package/src/vue/composables/useIsOpenFromVar.ts

@@ -1,61 +1,61 @@
-import { ref, computed, type Ref, type ComputedRef } from 'vue'
-import useIsEmpty from './useIsEmpty'
-
-export default function <FromVarType>(
-  defaultValue: FromVarType | undefined = undefined,
-  delay: number = 500
-): {
-  fromVar: ComputedRef<FromVarType | undefined>
-  isOpenFromVar: ComputedRef<boolean>
-  isOpenFromVarKey: Ref<number>
-} {
-  const isOpenFromVarKey = ref<number>(0)
-
-  const { isNotEmpty } = useIsEmpty()
-
-  const internalIsOpen = ref<boolean>(false)
-
-  const internalFromVar = ref<FromVarType | undefined>(defaultValue)
-
-  const isOpenFromVar = computed({
-    get(): boolean {
-      return internalIsOpen.value
-    },
-    set(value): void {
-      if (value) {
-        internalIsOpen.value = true
-
-        internalFromVar.value = value
-      } else {
-        internalIsOpen.value = false
-
-        setTimeout((): void => {
-          internalFromVar.value = defaultValue
-
-          isOpenFromVarKey.value++
-        }, delay)
-      }
-    }
-  })
-
-  const fromVar = computed({
-    get(): FromVarType | undefined {
-      return internalFromVar.value
-    },
-    set(value): void {
-      if (isNotEmpty(value)) {
-        isOpenFromVar.value = true
-
-        internalFromVar.value = value
-      } else {
-        isOpenFromVar.value = false
-      }
-    }
-  })
-
-  return {
-    fromVar,
-    isOpenFromVar,
-    isOpenFromVarKey
-  }
-}
+import { ref, computed, type Ref, type ComputedRef } from 'vue'
+import useIsEmpty from './useIsEmpty'
+
+export default function <FromVarType>(
+  defaultValue: FromVarType | undefined = undefined,
+  delay: number = 500
+): {
+  fromVar: ComputedRef<FromVarType | undefined>
+  isOpenFromVar: ComputedRef<boolean>
+  isOpenFromVarKey: Ref<number>
+} {
+  const isOpenFromVarKey = ref<number>(0)
+
+  const { isNotEmpty } = useIsEmpty()
+
+  const internalIsOpen = ref<boolean>(false)
+
+  const internalFromVar = ref<FromVarType | undefined>(defaultValue)
+
+  const isOpenFromVar = computed({
+    get(): boolean {
+      return internalIsOpen.value
+    },
+    set(value): void {
+      if (value) {
+        internalIsOpen.value = true
+
+        internalFromVar.value = value
+      } else {
+        internalIsOpen.value = false
+
+        setTimeout((): void => {
+          internalFromVar.value = defaultValue
+
+          isOpenFromVarKey.value++
+        }, delay)
+      }
+    }
+  })
+
+  const fromVar = computed({
+    get(): FromVarType | undefined {
+      return internalFromVar.value
+    },
+    set(value): void {
+      if (isNotEmpty(value)) {
+        isOpenFromVar.value = true
+
+        internalFromVar.value = value
+      } else {
+        isOpenFromVar.value = false
+      }
+    }
+  })
+
+  return {
+    fromVar,
+    isOpenFromVar,
+    isOpenFromVarKey
+  }
+}