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

package/src/requests/exceptions/index.ts

@@ -1,51 +0,0 @@
-import { ValidationException } from './ValidationException'
-import { NotFoundException } from './NotFoundException'
-import { NoResponseReceivedException } from './NoResponseReceivedException'
-import { UnauthorizedException } from './UnauthorizedException'
-import { ForbiddenException } from './ForbiddenException'
-import { BadRequestException } from './BadRequestException'
-import { MethodNotAllowedException } from './MethodNotAllowedException'
-import { RequestTimeoutException } from './RequestTimeoutException'
-import { ConflictException } from './ConflictException'
-import { GoneException } from './GoneException'
-import { PreconditionFailedException } from './PreconditionFailedException'
-import { PayloadTooLargeException } from './PayloadTooLargeException'
-import { UnsupportedMediaTypeException } from './UnsupportedMediaTypeException'
-import { PageExpiredException } from './PageExpiredException'
-import { ServerErrorException } from './ServerErrorException'
-import { NotImplementedException } from './NotImplementedException'
-import { BadGatewayException } from './BadGatewayException'
-import { ServiceUnavailableException } from './ServiceUnavailableException'
-import { GatewayTimeoutException } from './GatewayTimeoutException'
-import { TooManyRequestsException } from './TooManyRequestsException'
-import { LockedException } from './LockedException'
-import { InvalidJsonException } from './InvalidJsonException'
-import { ResponseException } from './ResponseException'
-import { ResponseBodyException } from './ResponseBodyException'
-
-export {
-  ValidationException,
-  NotFoundException,
-  NoResponseReceivedException,
-  UnauthorizedException,
-  PageExpiredException,
-  ServerErrorException,
-  NotImplementedException,
-  BadGatewayException,
-  ServiceUnavailableException,
-  GatewayTimeoutException,
-  TooManyRequestsException,
-  LockedException,
-  InvalidJsonException,
-  ResponseException,
-  ResponseBodyException,
-  ForbiddenException,
-  BadRequestException,
-  MethodNotAllowedException,
-  RequestTimeoutException,
-  ConflictException,
-  GoneException,
-  PreconditionFailedException,
-  PayloadTooLargeException,
-  UnsupportedMediaTypeException
-}

package/src/requests/factories/FormDataFactory.ts

@@ -1,17 +0,0 @@
-import { FormDataBody } from '../bodies/FormDataBody'
-import { type BodyFactoryContract } from '../contracts/BodyFactoryContract'
-import { type BodyContract } from '../contracts/BodyContract'
-
-type FormDataPrimitive = string | number | boolean | null | Date | Blob
-
-export type FormDataValue = FormDataPrimitive | FormDataValue[] | { [key: string]: FormDataValue }
-
-export class FormDataFactory<
-  RequestBodyInterface extends {
-    [K in keyof RequestBodyInterface]: FormDataValue | undefined
-  }
-> implements BodyFactoryContract<RequestBodyInterface> {
-  public make(body: RequestBodyInterface): BodyContract {
-    return new FormDataBody<RequestBodyInterface>(body)
-  }
-}

package/src/requests/factories/JsonBodyFactory.ts

@@ -1,9 +0,0 @@
-import { JsonBody } from '../bodies/JsonBody'
-import { type BodyFactoryContract } from '../contracts/BodyFactoryContract'
-import { type BodyContract } from '../contracts/BodyContract'
-
-export class JsonBodyFactory<RequestBodyInterface> implements BodyFactoryContract<RequestBodyInterface> {
-  public make(body: RequestBodyInterface): BodyContract {
-    return new JsonBody<RequestBodyInterface>(body)
-  }
-}

package/src/requests/index.ts

@@ -1,61 +0,0 @@
-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 { RequestErrorRouter } from './RequestErrorRouter'
-import { RequestEvents } from './RequestEvents.enum'
-import { RequestMethodEnum } from './RequestMethod.enum'
-import { RequestConcurrencyMode } from './RequestConcurrencyMode.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 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 { StaleResponseException } from './exceptions/StaleResponseException'
-import { type HeaderValue, type HeadersContract } from './contracts/HeadersContract'
-import { type RequestConcurrencyOptions } from './types/RequestConcurrencyOptions'
-import { type RequestUploadProgress } from './types/RequestUploadProgress'
-import { XMLHttpRequestDriver } from './drivers/xhr/XMLHttpRequestDriver'
-
-export {
-  FetchDriver,
-  BaseResponse,
-  JsonResponse,
-  BlobResponse,
-  PlainTextResponse,
-  BaseRequest,
-  ErrorHandler,
-  RequestErrorRouter,
-  RequestEvents,
-  RequestMethodEnum,
-  RequestConcurrencyMode,
-  ResponseException,
-  StaleResponseException,
-  JsonBodyFactory,
-  FormDataFactory,
-  XMLHttpRequestDriver
-}
-
-export type {
-  RequestDriverContract,
-  RequestLoaderContract,
-  BodyContract,
-  RequestLoaderFactoryContract,
-  DriverConfigContract,
-  BodyFactoryContract,
-  ResponseHandlerContract,
-  BaseRequestContract,
-  HeaderValue,
-  HeadersContract,
-  RequestConcurrencyOptions,
-  RequestUploadProgress
-}

package/src/requests/responses/BaseResponse.ts

@@ -1,41 +0,0 @@
-import { type ResponseHandlerContract } from '../drivers/contracts/ResponseHandlerContract'
-import { type HeadersContract } from '../contracts/HeadersContract'
-import { type ResponseContract } from '../contracts/ResponseContract'
-
-export abstract class BaseResponse<ResponseInterface> implements ResponseContract<ResponseInterface> {
-  private body?: ResponseInterface
-
-  protected response?: ResponseHandlerContract
-
-  public abstract getAcceptHeader(): string
-
-  protected abstract resolveBody(): Promise<ResponseInterface>
-
-  public async setResponse(response: ResponseHandlerContract): Promise<ResponseInterface> {
-    this.response = response
-
-    this.body = await this.resolveBody()
-
-    return this.body
-  }
-
-  public getRawResponse(): Response | undefined {
-    return this.response?.getRawResponse()
-  }
-
-  public getStatusCode(): number | undefined {
-    return this.response?.getStatusCode()
-  }
-
-  public getHeaders(): HeadersContract | undefined {
-    return this.response?.getHeaders()
-  }
-
-  public getBody(): ResponseInterface {
-    if (this.body === undefined) {
-      throw new Error('Response body is not set')
-    }
-
-    return this.body
-  }
-}

package/src/requests/responses/BlobResponse.ts

@@ -1,19 +0,0 @@
-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/requests/responses/JsonResponse.ts

@@ -1,15 +0,0 @@
-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/requests/responses/PlainTextResponse.ts

@@ -1,15 +0,0 @@
-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/requests/types/RequestUploadProgress.ts

@@ -1,6 +0,0 @@
-export interface RequestUploadProgress {
-  loaded: number
-  total?: number | undefined
-  lengthComputable: boolean
-  progress?: number | undefined
-}

package/src/support/DeferredPromise.ts

@@ -1,67 +0,0 @@
-/**
- * A new instance of deferred is constructed by calling `new DeferredPromse<T>()`.
- * The purpose of the deferred object is to expose the associated Promise
- * instance APIs that can be used for signaling the successful
- * or unsuccessful completion, as well as the state of the task.
- * @export
- * @class DeferredPromise
- * @implements {Promise<T>}
- * @template T
- * @example
- * const deferred = new DeferredPromse<string>();
- * console.log(deferred.state); // 'pending'
- *
- * deferred
- * .then(str => console.log(str))
- * .catch(err => console.error(err));
- *
- * deferred.resolve('Foo');
- * console.log(deferred.state); // 'fulfilled'
- * // deferred.reject('Bar');
- *
- * https://gist.github.com/GFoley83/5877f6c09fbcfd62569c51dc91444cf0
- */
-export class DeferredPromise<T> implements Promise<T> {
-  readonly [Symbol.toStringTag] = 'Promise' as const
-
-  private _promise: Promise<T>
-  private _resolve!: (value: T | PromiseLike<T>) => void
-  private _reject!: (reason?: unknown) => void
-  private _state: 'pending' | 'fulfilled' | 'rejected' = 'pending'
-
-  public get state(): 'pending' | 'fulfilled' | 'rejected' {
-    return this._state
-  }
-
-  public constructor() {
-    this._promise = new Promise<T>((resolve, reject) => {
-      this._resolve = resolve
-      this._reject = reject
-    })
-  }
-
-  public then<TResult1 = T, TResult2 = never>(
-    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
-    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null
-  ): Promise<TResult1 | TResult2> {
-    return this._promise.then(onfulfilled, onrejected)
-  }
-
-  public catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult> {
-    return this._promise.catch(onrejected)
-  }
-
-  public finally(onfinally?: (() => void) | null): Promise<T> {
-    return this._promise.finally(onfinally)
-  }
-
-  public resolve(value: T | PromiseLike<T>): void {
-    this._resolve(value)
-    this._state = 'fulfilled'
-  }
-
-  public reject(reason?: unknown): void {
-    this._reject(reason)
-    this._state = 'rejected'
-  }
-}

package/src/support/helpers.ts

@@ -1,78 +0,0 @@
-export const getCookie = (cname: string) => {
-  const name = cname + '='
-  const decodedCookie = decodeURIComponent(document.cookie)
-  const ca = decodedCookie.split(';')
-  for (let i = 0; i < ca.length; i++) {
-    let c = ca[i]
-
-    if (c === undefined) {
-      return ''
-    }
-
-    while (c.charAt(0) == ' ') {
-      c = c.substring(1)
-    }
-    if (c.indexOf(name) == 0) {
-      return c.substring(name.length, c.length)
-    }
-  }
-  return ''
-}
-
-export const isObject = (item: unknown): boolean => {
-  if (!item) {
-    return false
-  }
-
-  if (Array.isArray(item)) {
-    return false
-  }
-
-  return typeof item === 'object'
-}
-
-export const mergeDeep = (target: object, ...sources: object[]): object => {
-  if (!sources.length) return target
-  const source = sources.shift()
-
-  if (isObject(target) && isObject(source)) {
-    for (const key in source) {
-      // @ts-expect-error unknown structure
-      if (isObject(source[key])) {
-        // @ts-expect-error unknown structure
-        if (!target[key]) Object.assign(target, { [key]: {} })
-        // @ts-expect-error unknown structure
-        mergeDeep(target[key], source[key])
-      } else {
-        // @ts-expect-error unknown structure
-        Object.assign(target, { [key]: source[key] })
-      }
-    }
-  }
-
-  return mergeDeep(target, ...sources)
-}
-
-export const getDisplayablePages = (totalPages: number, pageNumber: number, displayPages: number = 4) => {
-  if (totalPages < displayPages) {
-    displayPages = totalPages
-  }
-
-  let offset = 0
-
-  const middlePage = Math.ceil(displayPages / 2)
-
-  if (pageNumber <= middlePage) {
-    offset = 0
-  } else if (pageNumber > totalPages - middlePage) {
-    offset = totalPages - displayPages
-  } else {
-    offset = pageNumber - middlePage
-  }
-
-  return [...Array(displayPages).keys()].map((i) => i + 1 + offset)
-}
-
-export const isAtBottom = (scrollHeight: number, scrollTop: number, clientHeight: number): boolean => {
-  return Math.abs(scrollHeight - scrollTop - clientHeight) <= 3.0
-}

package/src/vue/composables/useConfirmDialog.ts

@@ -1,63 +0,0 @@
-import { getCurrentInstance, h, onUnmounted, render } from 'vue'
-import { type Component } from 'vue'
-
-export enum ConfirmDialogSeverity {
-  INFO = 'info',
-  WARNING = 'warning',
-  DANGER = 'danger'
-}
-
-export interface ConfirmDialogOptions {
-  getMessage(): string
-
-  getSeverity(): ConfirmDialogSeverity
-
-  getTitle(): string
-
-  getOkText(): string
-
-  getCancelText(): string
-}
-
-/**
- * The provided component needs to expose an "open" method, which
- * should return a promise resolving into true or false.
- */
-export default function (confirmDialogComponent: Component, querySelector: string = 'body') {
-  const self = getCurrentInstance()
-
-  /**
-   * https://stackoverflow.com/a/78448128
-   */
-  function mountConfirmDialog(options: ConfirmDialogOptions) {
-    if (!self?.appContext) {
-      throw new Error('ConfirmationDialog: useConfirmDialog must be called inside a setup function')
-    }
-
-    const vNode = h(confirmDialogComponent, { options })
-    vNode.key = Symbol()
-    vNode.appContext = self.appContext
-    render(vNode, document.querySelector(querySelector) as Element)
-    return vNode.component
-  }
-
-  function unmountConfirmDialog() {
-    render(null, document.querySelector(querySelector) as Element)
-  }
-
-  onUnmounted(() => {
-    unmountConfirmDialog()
-  })
-
-  async function openConfirmDialog(options: ConfirmDialogOptions): Promise<boolean> {
-    const dialogComponent = mountConfirmDialog(options)
-
-    if (dialogComponent?.exposed == undefined || dialogComponent?.exposed['open'] === undefined) {
-      throw new Error('ConfirmationDialog: Provided component does not expose an "open" method')
-    }
-
-    return dialogComponent?.exposed['open']
-  }
-
-  return { openConfirmDialog }
-}

package/src/vue/composables/useGlobalCheckbox.ts

@@ -1,145 +0,0 @@
-import { getCurrentInstance, shallowRef, computed, type Component, type Ref, type ComputedRef, h, render, onUnmounted } from 'vue'
-
-interface UseGlobalCheckboxOptions<T> {
-  getAll: () => Promise<T[]>
-  getPage: () => T[]
-  totalCount: () => number
-}
-
-export default function <T>(
-  dialog: Component,
-  options: UseGlobalCheckboxOptions<T>,
-  querySelector: string = 'body'
-): {
-  selectedRows: Ref<T[]>
-  indeterminate: ComputedRef<boolean>
-  checked: ComputedRef<boolean>
-  handleGlobalCheckboxChange: (event: Event) => void
-} {
-  const self = getCurrentInstance()
-  const selectedRows = shallowRef<T[]>([])
-
-  function mountDialog() {
-    if (!self?.appContext) {
-      throw new Error('useGlobalCheckbox must be called inside a setup function')
-    }
-
-    const vNode = h(dialog, {
-      indeterminate: indeterminate.value,
-      checked: checked.value
-    })
-    vNode.key = Symbol()
-    vNode.appContext = self.appContext
-    render(vNode, document.querySelector(querySelector) as Element)
-    return vNode.component
-  }
-
-  function unmountConfirmDialog() {
-    render(null, document.querySelector(querySelector) as Element)
-  }
-
-  onUnmounted(() => {
-    unmountConfirmDialog()
-  })
-
-  const indeterminate = computed(() => {
-    const totalCount: number = options.totalCount()
-    return selectedRows.value.length > 0 && selectedRows.value.length < totalCount
-  })
-
-  const checked = computed({
-    get: () => {
-      const totalCount: number = options.totalCount()
-
-      return selectedRows.value.length > 0 && selectedRows.value.length === totalCount
-    },
-    set: (value: boolean) => {
-      if (!value) {
-        selectedRows.value = []
-      }
-    }
-  })
-
-  // Check if all elements are already displayed on the current page
-  const isAllElementsOnCurrentPage = (): boolean => {
-    return options.getPage().length === options.totalCount()
-  }
-
-  async function handleGlobalCheckboxChange(event: Event) {
-    if (!(event.target instanceof HTMLInputElement)) {
-      return
-    }
-
-    const pageData: T[] = options.getPage()
-
-    // If all elements are on the current page, we can skip the dialog
-    // as both options would result in the same selection
-    const allElementsOnPage = isAllElementsOnCurrentPage()
-
-    // Case 1: Nothing is selected (unchecked state)
-    if (!checked.value && !indeterminate.value) {
-      if (allElementsOnPage) {
-        // All elements are already on the current page, just select them
-        selectedRows.value = [...pageData]
-        return
-      }
-
-      // We need preventDefault() here because we're showing a dialog
-      // and don't want the checkbox to be checked until the user makes a choice
-      event.preventDefault()
-
-      const mountedDialog = mountDialog()
-      if (!mountedDialog?.exposed) return
-
-      // When clicking the empty checkbox, ask if user wants current page or all entries
-      if (await mountedDialog.exposed['open']) {
-        // User clicked "All Elements" button
-        selectedRows.value = await options.getAll()
-      } else {
-        // User clicked "Current Page" button
-        selectedRows.value = [...pageData]
-      }
-      return
-    }
-
-    // Case 2: Indeterminate state (some items selected, not all)
-    if (indeterminate.value) {
-      if (allElementsOnPage) {
-        // If all elements are on the page, just select them all
-        selectedRows.value = [...pageData]
-        return
-      }
-
-      // We need preventDefault() here because we're showing a dialog
-      // and don't want the checkbox to be checked until the user makes a choice
-      event.preventDefault()
-
-      const mountedDialog = mountDialog()
-      if (!mountedDialog?.exposed) return
-
-      // When clicking the indeterminate checkbox, ask if the user wants all entries or unselect all
-      if (await mountedDialog.exposed['open']) {
-        // User clicked "All Elements" button
-        selectedRows.value = await options.getAll()
-      } else {
-        // User clicked "Discard" button
-        selectedRows.value = []
-      }
-      return
-    }
-
-    // Case 3: Checked state (all items selected)
-    if (checked.value) {
-      // When all items are selected, we just clear the selection without a dialog
-      selectedRows.value = []
-      return
-    }
-  }
-
-  return {
-    selectedRows,
-    indeterminate,
-    checked,
-    handleGlobalCheckboxChange
-  }
-}

package/src/vue/composables/useIsEmpty.ts

@@ -1,34 +0,0 @@
-import { isEmpty as _isEmpty } from 'lodash-es'
-
-export default function () {
-  function isObject(value: unknown) {
-    return typeof value === 'object' && !Array.isArray(value) && value !== null
-  }
-
-  function isEmpty(value: unknown) {
-    // Check objects with lodash
-    if (isObject(value)) {
-      return _isEmpty(value)
-    }
-
-    // Check objects against their length property
-    if (Array.isArray(value)) {
-      return value.length === 0
-    }
-
-    if (value === '' || value === null) {
-      return true
-    }
-
-    return value === undefined
-  }
-
-  function isNotEmpty(value: unknown) {
-    return !isEmpty(value)
-  }
-
-  return {
-    isEmpty,
-    isNotEmpty
-  }
-}

package/src/vue/composables/useIsOpen.ts

@@ -1,37 +0,0 @@
-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
-  }
-}