@blueprint-ts/core 1.0.0

package/src/helpers.ts

@@ -0,0 +1,78 @@
+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/service/bulkRequests/BulkRequestEvent.enum.ts

@@ -0,0 +1,4 @@
+export enum BulkRequestEventEnum {
+  REQUEST_SUCCESSFUL = 'REQUEST_SUCCESSFUL',
+  REQUEST_FAILED = 'REQUEST_FAILED'
+}

package/src/service/bulkRequests/BulkRequestSender.ts

@@ -0,0 +1,184 @@
+import { BulkRequestWrapper } from './BulkRequestWrapper'
+import { BulkRequestEventEnum } from './BulkRequestEvent.enum'
+import { BaseRequest } from '../requests'
+
+export enum BulkRequestExecutionMode {
+  PARALLEL = 'parallel',
+  SEQUENTIAL = 'sequential'
+}
+
+export class BulkRequestSender {
+  // @ts-expect-error
+  protected events: Map<BulkRequestEventEnum, ((req: BulkRequestWrapper<BaseRequest>) => void)[]> = new Map()
+  protected abortController: AbortController | undefined = undefined
+
+  public constructor(
+    // @ts-expect-error
+    protected requests: BulkRequestWrapper<BaseRequest>[] = [],
+    protected executionMode: BulkRequestExecutionMode = BulkRequestExecutionMode.PARALLEL,
+    protected retryCount: number = 0
+  ) {}
+
+  // @ts-expect-error
+  public setRequests(requests: BulkRequestWrapper<BaseRequest>[] = []) {
+    this.requests = requests
+
+    return this
+  }
+
+  public setExecutionMode(mode: BulkRequestExecutionMode): this {
+    this.executionMode = mode
+
+    return this
+  }
+
+  public setRetryCount(count: number): this {
+    this.retryCount = count
+
+    return this
+  }
+
+  public get isLoading(): boolean {
+    return this.requests.some((req) => req.isLoading())
+  }
+
+  // @ts-expect-error
+  public on(event: BulkRequestEventEnum, callback: (req: BulkRequestWrapper<BaseRequest>) => void): this {
+    if (!this.events.has(event)) {
+      this.events.set(event, [])
+    }
+
+    this.events.get(event)!.push(callback)
+
+    return this
+  }
+
+  public off(event: BulkRequestEventEnum): this {
+    this.events.delete(event)
+
+    return this
+  }
+
+  // @ts-expect-error
+  protected emit(event: BulkRequestEventEnum, req: BulkRequestWrapper<BaseRequest>): void {
+    const callbacks = this.events.get(event) || []
+
+    callbacks.forEach((callback) => callback(req))
+  }
+
+  public get signal(): AbortSignal | undefined {
+    return this.abortController?.signal
+  }
+
+  public abort(): void {
+    this.abortController?.abort()
+  }
+
+  public async send() {
+    this.abortController = new AbortController()
+
+    try {
+      if (this.executionMode === BulkRequestExecutionMode.PARALLEL) {
+        await this.sendParallel()
+      } else {
+        await this.sendSequential()
+      }
+    } catch (error) {
+      // If an abort occurs, the underlying fetch (or request mechanism) should throw an AbortError.
+      console.error('Bulk operation aborted or encountered an error:', error)
+    }
+
+    return {
+      getSuccessCount: () => this.requests.filter((r) => !r.getError()).length,
+      getErrorCount: () => this.requests.filter((r) => r.getError()).length,
+      getSuccessfulResponses: () => this.requests.filter((r) => !r.getError()).map((r) => r.getResponse()),
+      getFailedResponses: () => this.requests.filter((r) => r.getError()).map((r) => r.getError())
+    }
+  }
+
+  protected async sendParallel() {
+    // First attempt for all requests
+    await Promise.all(
+      this.requests.map((req) =>
+        req.send(this.abortController?.signal).then(() => {
+          if (!req.hasError()) {
+            this.emit(BulkRequestEventEnum.REQUEST_SUCCESSFUL, req)
+          }
+        })
+      )
+    )
+
+    // Retry logic for failed requests
+    let retriesLeft = this.retryCount
+    while (retriesLeft > 0) {
+      const failedRequests = this.requests.filter((req) => req.hasError())
+
+      if (failedRequests.length === 0) {
+        break // No failed requests to retry
+      }
+
+      console.log(`Retrying ${failedRequests.length} failed requests. Attempts left: ${retriesLeft}`)
+
+      await Promise.all(
+        failedRequests.map((req) =>
+          req.send(this.abortController?.signal).then(() => {
+            if (!req.hasError()) {
+              // Success after retry
+              this.emit(BulkRequestEventEnum.REQUEST_SUCCESSFUL, req)
+            }
+          })
+        )
+      )
+
+      retriesLeft--
+    }
+
+    // Emit failed events for any requests that still have errors after all retries
+    this.requests
+      .filter((req) => req.hasError())
+      .forEach((req) => {
+        this.emit(BulkRequestEventEnum.REQUEST_FAILED, req)
+      })
+  }
+
+  protected async sendSequential() {
+    // First attempt for all requests
+    for (const req of this.requests) {
+      await req.send(this.abortController?.signal)
+
+      if (!req.hasError()) {
+        this.emit(BulkRequestEventEnum.REQUEST_SUCCESSFUL, req)
+      }
+    }
+
+    // Retry logic for failed requests
+    let retriesLeft = this.retryCount
+    while (retriesLeft > 0) {
+      const failedRequests = this.requests.filter((req) => req.hasError())
+
+      if (failedRequests.length === 0) {
+        break // No failed requests to retry
+      }
+
+      console.log(`Retrying ${failedRequests.length} failed requests sequentially. Attempts left: ${retriesLeft}`)
+
+      for (const req of failedRequests) {
+        await req.send(this.abortController?.signal)
+
+        if (!req.hasError()) {
+          // Success after retry
+          this.emit(BulkRequestEventEnum.REQUEST_SUCCESSFUL, req)
+        }
+      }
+
+      retriesLeft--
+    }
+
+    // Emit failed events for any requests that still have errors after all retries
+    this.requests
+      .filter((req) => req.hasError())
+      .forEach((req) => {
+        this.emit(BulkRequestEventEnum.REQUEST_FAILED, req)
+      })
+  }
+}

package/src/service/bulkRequests/BulkRequestWrapper.ts

@@ -0,0 +1,49 @@
+import { type BaseRequestContract } from '../requests'
+
+export class BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface extends object> {
+  protected response: any = null
+  protected error: any = null
+  protected sent: boolean = false
+
+  public constructor(protected request: BaseRequestContract<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>) {}
+
+  public async send(signal?: AbortSignal) {
+    try {
+      if (signal !== undefined) {
+        this.request.setAbortSignal(signal)
+      }
+
+      this.response = await this.request.send()
+    } catch (err) {
+      console.error(err)
+
+      this.error = err
+    }
+
+    this.sent = true
+  }
+
+  public isLoading(): RequestLoaderLoadingType {
+    return this.request.isLoading()
+  }
+
+  public getResponse() {
+    return this.response
+  }
+
+  public getError() {
+    return this.error
+  }
+
+  public getRequest(): BaseRequestContract<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface> {
+    return this.request
+  }
+
+  public hasError(): boolean {
+    return Boolean(this.getError())
+  }
+
+  public wasSent(): boolean {
+    return this.sent
+  }
+}

package/src/service/bulkRequests/index.ts

@@ -0,0 +1,6 @@
+import { BulkRequestWrapper } from './BulkRequestWrapper'
+import { BulkRequestSender } from './BulkRequestSender'
+import { BulkRequestEventEnum } from './BulkRequestEvent.enum'
+import { BulkRequestExecutionMode } from './BulkRequestSender'
+
+export { BulkRequestEventEnum, BulkRequestWrapper, BulkRequestSender, BulkRequestExecutionMode }

package/src/service/laravel/pagination/contracts/PaginationParamsContract.ts

@@ -0,0 +1,4 @@
+export interface PaginationParamsContract {
+  page_size: number
+  page_number: number
+}

package/src/service/laravel/pagination/contracts/PaginationResponseBodyContract.ts

@@ -0,0 +1,6 @@
+export interface PaginationResponseBodyContract<ResourceInterface> {
+  data: ResourceInterface
+  meta: {
+    total: number
+  }
+}

package/src/service/laravel/pagination/dataDrivers/RequestDriver.ts

@@ -0,0 +1,32 @@
+import { PaginationDataDto } from '../../../pagination/dtos/PaginationDataDto'
+import { PaginationJsonBaseRequest } from '../../requests/PaginationJsonBaseRequest'
+import { PaginationResponse } from '../../requests/responses/PaginationResponse'
+import { type PaginateableRequestContract } from '../../../pagination/contracts/PaginateableRequestContract'
+import { type PaginationDataDriverContract } from '../../../pagination/contracts/PaginationDataDriverContract'
+
+type ExtractRequestTypes<T> =
+  T extends PaginationJsonBaseRequest<any, undefined, infer Resource, object>
+    ? {
+        Resource: Resource
+      }
+    : never
+
+export class RequestDriver<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  TReq extends PaginateableRequestContract<any, any, any, any>
+> implements PaginationDataDriverContract<ExtractRequestTypes<TReq>['Resource']> {
+  public constructor(protected request: TReq) {}
+
+  public get(pageNumber: number, pageSize: number): Promise<PaginationDataDto<ExtractRequestTypes<TReq>['Resource']>> {
+    return this.request
+      .setPaginationParams(pageNumber, pageSize)
+      .send()
+      .then((response: PaginationResponse<ExtractRequestTypes<TReq>['Resource']>) => {
+        return new PaginationDataDto<ExtractRequestTypes<TReq>['Resource']>(response.getData(), response.getTotal())
+      })
+  }
+
+  public getRequest(): TReq {
+    return this.request
+  }
+}

package/src/service/laravel/pagination/index.ts

@@ -0,0 +1,7 @@
+import { type PaginationParamsContract } from './contracts/PaginationParamsContract'
+import { type PaginationResponseBodyContract } from './contracts/PaginationResponseBodyContract'
+import { RequestDriver } from '../pagination/dataDrivers/RequestDriver'
+
+export type { PaginationParamsContract, PaginationResponseBodyContract }
+
+export { RequestDriver }

package/src/service/laravel/requests/JsonBaseRequest.ts

@@ -0,0 +1,35 @@
+import { BaseRequest } from '../../requests/BaseRequest'
+import { JsonResponse } from './responses/JsonResponse'
+import { JsonBodyFactory } from '../../requests/factories/JsonBodyFactory'
+import { type BodyFactoryContract } from '../../requests/contracts/BodyFactoryContract'
+
+export interface JsonResponseInterface<ResourceInterface> {
+  data: ResourceInterface
+}
+
+/**
+ * This requests expects a response in the JSON format
+ * and automatically sets the required headers.
+ */
+export abstract class JsonBaseRequest<
+  RequestLoaderLoadingType,
+  ResponseErrorBody,
+  ResourceInterface,
+  RequestBodyInterface = undefined,
+  RequestParamsInterface extends object = object
+> extends BaseRequest<
+  RequestLoaderLoadingType,
+  ResponseErrorBody,
+  JsonResponseInterface<ResourceInterface>,
+  JsonResponse<ResourceInterface>,
+  RequestBodyInterface,
+  RequestParamsInterface
+> {
+  public getResponse(): JsonResponse<ResourceInterface> {
+    return new JsonResponse<ResourceInterface>()
+  }
+
+  public override getRequestBodyFactory(): BodyFactoryContract<RequestBodyInterface | undefined> {
+    return new JsonBodyFactory<RequestBodyInterface>()
+  }
+}

package/src/service/laravel/requests/PaginationJsonBaseRequest.ts

@@ -0,0 +1,29 @@
+import { BaseRequest } from '../../requests/BaseRequest'
+import { type PaginationResponseBodyContract } from '../pagination/contracts/PaginationResponseBodyContract'
+import { type PaginationResponseContract } from '../../pagination/contracts/PaginationResponseContract'
+import { PaginationResponse } from './responses/PaginationResponse'
+
+export abstract class PaginationJsonBaseRequest<
+  RequestLoaderLoadingType,
+  ResponseErrorBodyInterface,
+  ResourceInterface,
+  RequestParamsInterface extends object
+> extends BaseRequest<
+  RequestLoaderLoadingType,
+  ResponseErrorBodyInterface,
+  PaginationResponseBodyContract<ResourceInterface>,
+  PaginationResponseContract<PaginationResponseBodyContract<ResourceInterface>, ResourceInterface>,
+  undefined,
+  RequestParamsInterface
+> {
+  public getResponse(): PaginationResponse<ResourceInterface> {
+    return new PaginationResponse()
+  }
+
+  public setPaginationParams(page: number, size: number): this {
+    return this.withParams({
+      page_number: page,
+      page_size: size
+    } as RequestParamsInterface)
+  }
+}

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

@@ -0,0 +1,9 @@
+import { JsonResponse } from './responses/JsonResponse'
+import { PaginationResponse } from './responses/PaginationResponse'
+import { JsonBaseRequest } from './JsonBaseRequest'
+import { PaginationJsonBaseRequest } from './PaginationJsonBaseRequest'
+import { type JsonResponseInterface } from './JsonBaseRequest'
+
+export { JsonResponse, PaginationResponse, JsonBaseRequest, PaginationJsonBaseRequest }
+
+export type { JsonResponseInterface }

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

@@ -0,0 +1,8 @@
+import { JsonResponse as ParentJsonResponse } from '../../../requests/responses/JsonResponse'
+import { type JsonResponseInterface } from '../JsonBaseRequest'
+
+export class JsonResponse<ResourceInterface> extends ParentJsonResponse<JsonResponseInterface<ResourceInterface>> {
+  public getData(): ResourceInterface {
+    return this.getBody().data
+  }
+}

package/src/service/laravel/requests/responses/PaginationResponse.ts

@@ -0,0 +1,16 @@
+import { JsonResponse } from '../../../requests/responses/JsonResponse'
+import { type PaginationResponseBodyContract } from '../../pagination/contracts/PaginationResponseBodyContract'
+import { type PaginationResponseContract } from '../../../pagination/contracts/PaginationResponseContract'
+
+export class PaginationResponse<ResourceInterface>
+  extends JsonResponse<PaginationResponseBodyContract<ResourceInterface>>
+  implements PaginationResponseContract<PaginationResponseBodyContract<ResourceInterface>, ResourceInterface>
+{
+  public getTotal(): number {
+    return this.getBody().meta.total
+  }
+
+  public getData(): ResourceInterface {
+    return this.getBody().data
+  }
+}

package/src/service/pagination/InfiniteScroller.ts

@@ -0,0 +1,21 @@
+import { Paginator } from './Paginator'
+import { PaginationDataDto } from './dtos/PaginationDataDto'
+import { type PaginatorLoadDataOptions } from './contracts/PaginatorLoadDataOptions'
+
+export class InfiniteScroller<ResourceInterface> extends Paginator<ResourceInterface> {
+  protected override passDataToViewDriver(dto: PaginationDataDto<ResourceInterface[]>, options: PaginatorLoadDataOptions = {}) {
+    const { flush = false, replace = false } = options
+
+    if (flush) {
+      this.flush()
+    }
+
+    if (replace) {
+      this.viewDriver.setData(dto.getData())
+    } else {
+      this.viewDriver.setData(this.viewDriver.getData().concat(dto.getData()))
+    }
+
+    this.viewDriver.setTotal(dto.getTotal())
+  }
+}

package/src/service/pagination/Paginator.ts

@@ -0,0 +1,149 @@
+import { PaginationDataDto } from './dtos/PaginationDataDto'
+import { type ViewDriverContract } from './contracts/ViewDriverContract'
+import { type ViewDriverFactoryContract } from './contracts/ViewDriverFactoryContract'
+import { type PaginatorLoadDataOptions } from './contracts/PaginatorLoadDataOptions'
+import { type PaginationDataDriverContract } from './contracts/PaginationDataDriverContract'
+
+export interface PaginatorOptions {
+  viewDriverFactory?: ViewDriverFactoryContract
+}
+
+export class Paginator<ResourceInterface> {
+  protected initialized: boolean = false
+
+  protected static viewDriverFactory: ViewDriverFactoryContract
+
+  protected viewDriver: ViewDriverContract<ResourceInterface[]>
+
+  public static setViewDriverFactory(value: ViewDriverFactoryContract): void {
+    Paginator.viewDriverFactory = value
+  }
+
+  public constructor(
+    protected dataDriver: PaginationDataDriverContract<ResourceInterface[]>,
+    pageNumber: number = 1,
+    pageSize: number = 10,
+    options?: PaginatorOptions
+  ) {
+    this.viewDriver = options?.viewDriverFactory
+      ? options.viewDriverFactory.make<ResourceInterface>(pageNumber, pageSize)
+      : Paginator.viewDriverFactory.make<ResourceInterface>(pageNumber, pageSize)
+  }
+
+  public setDataDriver(dataDriver: PaginationDataDriverContract<ResourceInterface[]>): this {
+    this.dataDriver = dataDriver
+
+    return this
+  }
+
+  public getDataDriver(): PaginationDataDriverContract<ResourceInterface[]> {
+    return this.dataDriver
+  }
+
+  public init(pageNumber: number, pageSize: number): Promise<PaginationDataDto<ResourceInterface[]>> {
+    this.initialized = true
+
+    if (pageNumber && pageSize) {
+      return this.loadData(pageNumber, pageSize)
+    }
+
+    return this.loadData(this.getCurrentPage(), this.getPageSize())
+  }
+
+  public refresh(pageNumber?: number, options?: PaginatorLoadDataOptions): Promise<PaginationDataDto<ResourceInterface[]>> {
+    if (pageNumber !== undefined) {
+      return this.setPage(pageNumber, options)
+    }
+
+    return this.loadData(this.getCurrentPage(), this.getPageSize(), options)
+  }
+
+  public flush(): void {
+    this.viewDriver.setData([])
+  }
+
+  public setPage(pageNumber: number, options?: PaginatorLoadDataOptions): Promise<PaginationDataDto<ResourceInterface[]>> {
+    this.viewDriver.setPage(pageNumber)
+
+    return this.loadData(this.viewDriver.getCurrentPage(), this.viewDriver.getPageSize(), options)
+  }
+
+  public isInitialized(): boolean {
+    return this.initialized
+  }
+
+  public getLastPage(): number {
+    return this.viewDriver.getLastPage()
+  }
+
+  public toNextPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
+    return this.setPage(this.getCurrentPage() + 1)
+  }
+
+  public toFirstPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
+    return this.setPage(1)
+  }
+
+  public toLastPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
+    return this.setPage(this.viewDriver.getLastPage())
+  }
+
+  public toPreviousPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
+    return this.setPage(this.getCurrentPage() - 1)
+  }
+
+  public getPageData(): ResourceInterface[] {
+    return this.viewDriver.getData()
+  }
+
+  public getCurrentPage(): number {
+    return this.viewDriver.getCurrentPage()
+  }
+
+  public getFromItemNumber(): number {
+    return (this.getCurrentPage() - 1) * this.getPageSize() + 1
+  }
+
+  public getToItemNumber(): number {
+    return this.getCurrentPage() * this.getPageSize()
+  }
+
+  public getTotal(): number {
+    return this.viewDriver.getTotal()
+  }
+
+  public getPageSize(): number {
+    return this.viewDriver.getPageSize()
+  }
+
+  public setPageSize(pageSize: number): Promise<PaginationDataDto<ResourceInterface[]>> {
+    this.viewDriver.setPageSize(pageSize)
+
+    if (this.getCurrentPage() * pageSize > this.getTotal()) {
+      return this.setPage(1)
+    }
+
+    return this.loadData(this.viewDriver.getCurrentPage(), this.viewDriver.getPageSize())
+  }
+
+  public getPages(): number[] {
+    return this.viewDriver.getPages()
+  }
+
+  protected loadData(pageNumber: number, pageSize: number, options?: PaginatorLoadDataOptions): Promise<PaginationDataDto<ResourceInterface[]>> {
+    return this.dataDriver.get(pageNumber, pageSize).then((value: PaginationDataDto<ResourceInterface[]>) => {
+      this.passDataToViewDriver(value, options)
+
+      return value
+    })
+  }
+
+  protected passDataToViewDriver(dto: PaginationDataDto<ResourceInterface[]>, options?: PaginatorLoadDataOptions): void {
+    if (options?.flush) {
+      this.flush()
+    }
+
+    this.viewDriver.setData(dto.getData())
+    this.viewDriver.setTotal(dto.getTotal())
+  }
+}

package/src/service/pagination/contracts/PaginateableRequestContract.ts

@@ -0,0 +1,13 @@
+import { type BaseRequestContract } from '../../requests/contracts/BaseRequestContract'
+
+export interface PaginateableRequestContract<
+  RequestLoaderLoadingType,
+  ResponseClass,
+  RequestBodyInterface,
+  RequestParamsInterface extends object
+> extends BaseRequestContract<RequestLoaderLoadingType, ResponseClass, RequestBodyInterface, RequestParamsInterface> {
+  setPaginationParams(
+    page: number,
+    size: number
+  ): BaseRequestContract<RequestLoaderLoadingType, ResponseClass, RequestBodyInterface, RequestParamsInterface>
+}

package/src/service/pagination/contracts/PaginationDataDriverContract.ts

@@ -0,0 +1,5 @@
+import { PaginationDataDto } from '../dtos/PaginationDataDto'
+
+export interface PaginationDataDriverContract<ResourceInterface> {
+  get(pageNumber: number, pageSize: number): Promise<PaginationDataDto<ResourceInterface>>
+}

package/src/service/pagination/contracts/PaginationResponseContract.ts

@@ -0,0 +1,7 @@
+import { type ResponseContract } from '../../requests/contracts/ResponseContract'
+
+export interface PaginationResponseContract<ResponseBodyInterface, ResourceInterface> extends ResponseContract<ResponseBodyInterface> {
+  getData(): ResourceInterface
+
+  getTotal(): number
+}