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

package/tests/service/requests/Responses.test.ts

@@ -1,83 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { BaseResponse } from '../../../src/requests/responses/BaseResponse'
-import { JsonResponse } from '../../../src/requests/responses/JsonResponse'
-import { PlainTextResponse } from '../../../src/requests/responses/PlainTextResponse'
-import { BlobResponse } from '../../../src/requests/responses/BlobResponse'
-import type { ResponseHandlerContract } from '../../../src/requests/drivers/contracts/ResponseHandlerContract'
-
-class TestResponse extends BaseResponse<string> {
-  public getAcceptHeader(): string {
-    return 'text/plain'
-  }
-
-  protected resolveBody(): Promise<string> {
-    return Promise.resolve('ok')
-  }
-}
-
-const mockResponseHandler: ResponseHandlerContract = {
-  getStatusCode: () => 200,
-  getHeaders: () => ({ 'x-test': 'yes' }),
-  getRawResponse: () => new Response('raw'),
-  json: async () => ({ ok: true }),
-  text: async () => 'plain',
-  blob: async () => new Blob(['blob'], { type: 'text/plain' }),
-}
-
-describe('Response classes', () => {
-  it('BaseResponse throws if body not set', () => {
-    const response = new TestResponse()
-
-    expect(() => response.getBody()).toThrow('Response body is not set')
-  })
-
-  it('BaseResponse stores response metadata and body', async () => {
-    const response = new TestResponse()
-
-    await response.setResponse(mockResponseHandler)
-
-    expect(response.getBody()).toBe('ok')
-    expect(response.getStatusCode()).toBe(200)
-    expect(response.getHeaders()).toEqual({ 'x-test': 'yes' })
-    expect(response.getRawResponse()).toBeInstanceOf(Response)
-  })
-
-  it('JsonResponse resolves JSON body', async () => {
-    const response = new JsonResponse<{ ok: boolean }>()
-
-    await response.setResponse(mockResponseHandler)
-
-    expect(response.getAcceptHeader()).toBe('application/json')
-    expect(response.getBody()).toEqual({ ok: true })
-  })
-
-  it('PlainTextResponse resolves text body', async () => {
-    const response = new PlainTextResponse()
-
-    await response.setResponse(mockResponseHandler)
-
-    expect(response.getAcceptHeader()).toBe('text/plain')
-    expect(response.getBody()).toBe('plain')
-  })
-
-  it('BlobResponse resolves blob body and uses mime type', async () => {
-    const response = new BlobResponse('application/pdf')
-
-    await response.setResponse(mockResponseHandler)
-
-    expect(response.getAcceptHeader()).toBe('application/pdf')
-    expect(response.getBody()).toBeInstanceOf(Blob)
-  })
-
-  it('throws when resolveBody is called without a response', () => {
-    const response = new JsonResponse()
-
-    expect(() => (response as any).resolveBody()).toThrow('Response is not set')
-
-    const plain = new PlainTextResponse()
-    expect(() => (plain as any).resolveBody()).toThrow('Response is not set')
-
-    const blob = new BlobResponse()
-    expect(() => (blob as any).resolveBody()).toThrow('Response is not set')
-  })
-})

package/tests/service/requests/exceptions/Exceptions.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { ResponseException } from '../../../../src/requests/exceptions/ResponseException'
-import { ResponseBodyException } from '../../../../src/requests/exceptions/ResponseBodyException'
-import { BadRequestException } from '../../../../src/requests/exceptions/BadRequestException'
-import { StaleResponseException } from '../../../../src/requests/exceptions/StaleResponseException'
-
-const mockResponse = {
-  getStatusCode: () => 400,
-  getHeaders: () => ({}),
-  getRawResponse: () => new Response(),
-  json: async () => ({}),
-  text: async () => '',
-  blob: async () => new Blob(),
-}
-
-describe('Request exceptions', () => {
-  it('ResponseException stores response', () => {
-    const exception = new ResponseException(mockResponse as any)
-
-    expect(exception.getResponse()).toBe(mockResponse)
-  })
-
-  it('ResponseBodyException stores response and body', () => {
-    const exception = new ResponseBodyException(mockResponse as any, { error: 'bad' })
-
-    expect(exception.getResponse()).toBe(mockResponse)
-    expect(exception.getBody()).toEqual({ error: 'bad' })
-  })
-
-  it('BadRequestException extends ResponseBodyException', () => {
-    const exception = new BadRequestException(mockResponse as any, { error: 'bad' })
-
-    expect(exception).toBeInstanceOf(ResponseBodyException)
-  })
-
-  it('StaleResponseException exposes cause', () => {
-    const cause = new Error('root')
-    const exception = new StaleResponseException('stale', cause)
-
-    expect(exception.message).toBe('stale')
-    expect(exception.getCause()).toBe(cause)
-  })
-})

package/tests/service/requests/fetch/FetchDriver.test.ts

@@ -1,94 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { FetchDriver } from '../../../../src/requests/drivers/fetch/FetchDriver'
-import { FetchResponse } from '../../../../src/requests/drivers/fetch/FetchResponse'
-import { RequestMethodEnum } from '../../../../src/requests/RequestMethod.enum'
-import { ResponseException } from '../../../../src/requests/exceptions/ResponseException'
-import type { BodyContent, BodyContract } from '../../../../src/requests/contracts/BodyContract'
-
-const createBody = (content: BodyContent, headers: Record<string, string> = { 'Content-Type': 'application/json' }): BodyContract => ({
-  getHeaders: () => headers,
-  getContent: () => content,
-})
-
-describe('FetchDriver', () => {
-  const originalFetch = global.fetch
-
-  beforeEach(() => {
-    global.fetch = vi.fn()
-  })
-
-  afterEach(() => {
-    global.fetch = originalFetch
-    vi.restoreAllMocks()
-  })
-
-  it('sends requests with merged headers and body', async () => {
-    const response = new Response('{"ok":true}', {
-      status: 200,
-      headers: { 'X-Response': 'yes' },
-    })
-
-    ;(global.fetch as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(response)
-
-    const driver = new FetchDriver({ headers: { 'X-Global': 'a' }, corsWithCredentials: true })
-
-    const result = await driver.send(
-      'https://example.com',
-      RequestMethodEnum.POST,
-      { 'X-Req': 'b', 'X-Fn': () => 'c', 'X-Ignore': undefined },
-      createBody('{"name":"test"}')
-    )
-
-    expect(result).toBeInstanceOf(FetchResponse)
-
-    const [, config] = (global.fetch as unknown as ReturnType<typeof vi.fn>).mock.calls[0]
-    expect(config.method).toBe('POST')
-    expect(config.credentials).toBe('include')
-    expect(config.headers).toEqual({
-      'X-Global': 'a',
-      'X-Req': 'b',
-      'X-Fn': 'c',
-      'Content-Type': 'application/json',
-    })
-    expect(config.body).toBe('{"name":"test"}')
-  })
-
-  it('omits body for GET/HEAD requests', async () => {
-    const response = new Response('ok', { status: 200 })
-    ;(global.fetch as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(response)
-
-    const driver = new FetchDriver()
-
-    await driver.send('https://example.com', RequestMethodEnum.GET, {}, createBody('data'))
-
-    const [, config] = (global.fetch as unknown as ReturnType<typeof vi.fn>).mock.calls[0]
-    expect(config.body).toBeUndefined()
-  })
-
-  it('passes Blob bodies through to fetch unchanged', async () => {
-    const response = new Response('ok', { status: 200 })
-    ;(global.fetch as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(response)
-
-    const blob = new Blob(['chunk'], { type: 'application/octet-stream' })
-    const driver = new FetchDriver()
-
-    await driver.send(
-      'https://example.com',
-      RequestMethodEnum.PUT,
-      {},
-      createBody(blob, { 'Content-Type': 'application/octet-stream' })
-    )
-
-    const [, config] = (global.fetch as unknown as ReturnType<typeof vi.fn>).mock.calls[0]
-    expect(config.body).toBe(blob)
-  })
-
-  it('throws ResponseException when response is not ok', async () => {
-    const response = new Response('fail', { status: 500 })
-    ;(global.fetch as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(response)
-
-    const driver = new FetchDriver()
-
-    await expect(driver.send('https://example.com', RequestMethodEnum.GET, {})).rejects.toBeInstanceOf(ResponseException)
-  })
-})

package/tests/service/requests/fetch/FetchResponse.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { FetchResponse } from '../../../../src/requests/drivers/fetch/FetchResponse'
-
-describe('FetchResponse', () => {
-  it('exposes response data', async () => {
-    const response = new Response('{"name":"Ada"}', {
-      status: 201,
-      headers: { 'X-Test': 'yes' },
-    })
-
-    const fetchResponse = new FetchResponse(response)
-
-    expect(fetchResponse.getStatusCode()).toBe(201)
-    expect(fetchResponse.getHeaders()).toEqual({
-      'content-type': 'text/plain;charset=UTF-8',
-      'x-test': 'yes',
-    })
-    expect(fetchResponse.getRawResponse()).toBe(response)
-    await expect(fetchResponse.json()).resolves.toEqual({ name: 'Ada' })
-  })
-})

package/tests/service/requests/xhr/XMLHttpRequestDriver.test.ts

@@ -1,197 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { XMLHttpRequestDriver } from '../../../../src/requests/drivers/xhr/XMLHttpRequestDriver'
-import { XMLHttpRequestResponse } from '../../../../src/requests/drivers/xhr/XMLHttpRequestResponse'
-import { RequestMethodEnum } from '../../../../src/requests/RequestMethod.enum'
-import { ResponseException } from '../../../../src/requests/exceptions/ResponseException'
-import type { BodyContent, BodyContract } from '../../../../src/requests/contracts/BodyContract'
-
-const createBody = (content: BodyContent, headers: Record<string, string> = { 'Content-Type': 'application/json' }): BodyContract => ({
-  getHeaders: () => headers,
-  getContent: () => content,
-})
-
-class MockXMLHttpRequestUpload {
-  public onprogress: ((event: ProgressEvent<EventTarget>) => void) | null = null
-}
-
-class MockXMLHttpRequest {
-  public static instances: MockXMLHttpRequest[] = []
-
-  public method?: string
-  public url?: string
-  public async?: boolean
-  public responseType: XMLHttpRequestResponseType = ''
-  public withCredentials = false
-  public status = 200
-  public statusText = 'OK'
-  public response: Blob | string | ArrayBuffer | null = '{"ok":true}'
-  public onload: (() => void) | null = null
-  public onerror: (() => void) | null = null
-  public onabort: (() => void) | null = null
-  public upload = new MockXMLHttpRequestUpload()
-  public headers: Record<string, string> = {}
-  public responseHeaders: Record<string, string> = {}
-  public sentBody: Document | XMLHttpRequestBodyInit | null | undefined = undefined
-  public aborted = false
-
-  public constructor() {
-    MockXMLHttpRequest.instances.push(this)
-  }
-
-  public open(method: string, url: string, async: boolean): void {
-    this.method = method
-    this.url = url
-    this.async = async
-  }
-
-  public setRequestHeader(key: string, value: string): void {
-    this.headers[key] = value
-  }
-
-  public send(body?: Document | XMLHttpRequestBodyInit | null): void {
-    this.sentBody = body
-  }
-
-  public abort(): void {
-    this.aborted = true
-    this.onabort?.()
-  }
-
-  public getAllResponseHeaders(): string {
-    return Object.entries(this.responseHeaders)
-      .map(([key, value]) => `${key}: ${value}`)
-      .join('\r\n')
-  }
-
-  public triggerLoad(): void {
-    this.onload?.()
-  }
-
-  public triggerError(): void {
-    this.onerror?.()
-  }
-
-  public triggerUploadProgress(loaded: number, total: number, lengthComputable: boolean = true): void {
-    this.upload.onprogress?.({
-      loaded,
-      total,
-      lengthComputable,
-    } as ProgressEvent<EventTarget>)
-  }
-}
-
-describe('XMLHttpRequestDriver', () => {
-  const originalXMLHttpRequest = global.XMLHttpRequest
-
-  beforeEach(() => {
-    MockXMLHttpRequest.instances = []
-    global.XMLHttpRequest = MockXMLHttpRequest as unknown as typeof XMLHttpRequest
-  })
-
-  afterEach(() => {
-    global.XMLHttpRequest = originalXMLHttpRequest
-    vi.restoreAllMocks()
-  })
-
-  it('sends requests with merged headers, body, and upload progress callbacks', async () => {
-    const onUploadProgress = vi.fn()
-    const driver = new XMLHttpRequestDriver({ headers: { 'X-Global': 'a' }, corsWithCredentials: true })
-
-    const promise = driver.send(
-      'https://example.com',
-      RequestMethodEnum.POST,
-      { 'X-Req': 'b', 'X-Fn': () => 'c', 'X-Ignore': undefined },
-      createBody('{"name":"test"}'),
-      { onUploadProgress }
-    )
-
-    const request = MockXMLHttpRequest.instances[0]
-    request.status = 201
-    request.responseHeaders = { 'X-Response': 'yes' }
-    request.triggerUploadProgress(5, 10)
-    request.triggerLoad()
-
-    const result = await promise
-
-    expect(result).toBeInstanceOf(XMLHttpRequestResponse)
-    expect(request.method).toBe('POST')
-    expect(request.url).toBe('https://example.com')
-    expect(request.async).toBe(true)
-    expect(request.responseType).toBe('blob')
-    expect(request.withCredentials).toBe(true)
-    expect(request.headers).toEqual({
-      'X-Global': 'a',
-      'X-Req': 'b',
-      'X-Fn': 'c',
-      'Content-Type': 'application/json',
-    })
-    expect(request.sentBody).toBe('{"name":"test"}')
-    expect(onUploadProgress).toHaveBeenCalledWith({
-      loaded: 5,
-      total: 10,
-      lengthComputable: true,
-      progress: 0.5,
-    })
-    await expect(result.json()).resolves.toEqual({ ok: true })
-  })
-
-  it('omits body for GET and HEAD requests', async () => {
-    const driver = new XMLHttpRequestDriver()
-
-    const promise = driver.send('https://example.com', RequestMethodEnum.GET, {}, createBody('data'))
-
-    const request = MockXMLHttpRequest.instances[0]
-    request.triggerLoad()
-
-    await promise
-
-    expect(request.sentBody).toBeUndefined()
-  })
-
-  it('passes typed array bodies through to xhr unchanged', async () => {
-    const driver = new XMLHttpRequestDriver()
-    const chunk = new Uint8Array([1, 2, 3, 4])
-
-    const promise = driver.send(
-      'https://example.com',
-      RequestMethodEnum.PUT,
-      {},
-      createBody(chunk, { 'Content-Type': 'application/octet-stream' })
-    )
-
-    const request = MockXMLHttpRequest.instances[0]
-    request.triggerLoad()
-
-    await promise
-
-    expect(request.sentBody).toBe(chunk)
-  })
-
-  it('throws ResponseException when the response status is not ok', async () => {
-    const driver = new XMLHttpRequestDriver()
-
-    const promise = driver.send('https://example.com', RequestMethodEnum.GET, {})
-
-    const request = MockXMLHttpRequest.instances[0]
-    request.status = 500
-    request.response = 'fail'
-    request.triggerLoad()
-
-    await expect(promise).rejects.toBeInstanceOf(ResponseException)
-  })
-
-  it('aborts requests when the AbortSignal is triggered', async () => {
-    const controller = new AbortController()
-    const driver = new XMLHttpRequestDriver()
-
-    const promise = driver.send('https://example.com', RequestMethodEnum.POST, {}, createBody('{"name":"test"}'), {
-      abortSignal: controller.signal,
-    })
-
-    const request = MockXMLHttpRequest.instances[0]
-    controller.abort()
-
-    await expect(promise).rejects.toMatchObject({ name: 'AbortError' })
-    expect(request.aborted).toBe(true)
-  })
-})

package/tests/service/support/DeferredPromise.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { DeferredPromise } from '../../../src/support/DeferredPromise'
-
-describe('DeferredPromise', () => {
-  it('resolves and updates state', async () => {
-    const deferred = new DeferredPromise<string>()
-
-    expect(deferred.state).toBe('pending')
-
-    const resultPromise = deferred.then((value) => `value:${value}`)
-    deferred.resolve('ok')
-
-    await expect(resultPromise).resolves.toBe('value:ok')
-    expect(deferred.state).toBe('fulfilled')
-  })
-
-  it('rejects and updates state', async () => {
-    const deferred = new DeferredPromise<string>()
-
-    const resultPromise = deferred.catch((error) => `error:${String(error)}`)
-    deferred.reject('boom')
-
-    await expect(resultPromise).resolves.toBe('error:boom')
-    expect(deferred.state).toBe('rejected')
-  })
-
-  it('supports finally', async () => {
-    const deferred = new DeferredPromise<string>()
-    let ran = false
-
-    const promise = deferred.finally(() => {
-      ran = true
-    })
-
-    deferred.resolve('ok')
-    await promise
-
-    expect(ran).toBe(true)
-  })
-})

package/tests/service/support/helpers.test.ts

@@ -1,37 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest'
-import { getCookie, getDisplayablePages, isAtBottom, isObject } from '../../../src/support/helpers'
-
-describe('support helpers', () => {
-  beforeEach(() => {
-    document.cookie = ''
-  })
-
-  it('reads cookies by name and trims spaces', () => {
-    document.cookie = 'first=one'
-    document.cookie = 'second=two'
-
-    expect(getCookie('first')).toBe('one')
-    expect(getCookie('second')).toBe('two')
-    expect(getCookie('missing')).toBe('')
-  })
-
-  it('detects objects and excludes arrays/null', () => {
-    expect(isObject({})).toBe(true)
-    expect(isObject({ a: 1 })).toBe(true)
-    expect(isObject([])).toBe(false)
-    expect(isObject(null)).toBe(false)
-    expect(isObject(undefined)).toBe(false)
-  })
-
-  it('calculates displayable pages with bounds', () => {
-    expect(getDisplayablePages(3, 1, 4)).toEqual([1, 2, 3])
-    expect(getDisplayablePages(10, 1, 4)).toEqual([1, 2, 3, 4])
-    expect(getDisplayablePages(10, 5, 4)).toEqual([4, 5, 6, 7])
-    expect(getDisplayablePages(10, 10, 4)).toEqual([7, 8, 9, 10])
-  })
-
-  it('detects near-bottom scroll positions', () => {
-    expect(isAtBottom(100, 97, 3)).toBe(true)
-    expect(isAtBottom(100, 90, 3)).toBe(false)
-  })
-})

package/tests/vue/composables/useConfirmDialog.test.ts

@@ -1,77 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { createApp, defineComponent, h } from 'vue'
-import useConfirmDialog, { ConfirmDialogSeverity, type ConfirmDialogOptions } from '../../../src/vue/composables/useConfirmDialog'
-
-const options: ConfirmDialogOptions = {
-  getMessage: () => 'Are you sure?',
-  getSeverity: () => ConfirmDialogSeverity.INFO,
-  getTitle: () => 'Confirm',
-  getOkText: () => 'OK',
-  getCancelText: () => 'Cancel',
-}
-
-describe('useConfirmDialog', () => {
-  it('throws when called outside setup', async () => {
-    const Dialog = defineComponent({ setup: () => () => h('div') })
-    const { openConfirmDialog } = useConfirmDialog(Dialog, '#dialog')
-
-    await expect(openConfirmDialog(options)).rejects.toThrow('useConfirmDialog must be called inside a setup function')
-  })
-
-  it('opens dialog and returns exposed result', async () => {
-    const dialogTarget = document.createElement('div')
-    dialogTarget.id = 'dialog'
-    document.body.appendChild(dialogTarget)
-
-    const Dialog = defineComponent({
-      setup(_, { expose }) {
-        expose({ open: Promise.resolve(true) })
-        return () => h('div')
-      },
-    })
-
-    let openConfirmDialog: (opts: ConfirmDialogOptions) => Promise<boolean>
-
-    const App = defineComponent({
-      setup() {
-        ;({ openConfirmDialog } = useConfirmDialog(Dialog, '#dialog'))
-        return () => h('div')
-      },
-    })
-
-    const root = document.createElement('div')
-    document.body.appendChild(root)
-
-    createApp(App).mount(root)
-
-    await expect(openConfirmDialog(options)).resolves.toBe(true)
-  })
-
-  it('throws when dialog does not expose open', async () => {
-    const dialogTarget = document.createElement('div')
-    dialogTarget.id = 'dialog-2'
-    document.body.appendChild(dialogTarget)
-
-    const Dialog = defineComponent({
-      setup() {
-        return () => h('div')
-      },
-    })
-
-    let openConfirmDialog: (opts: ConfirmDialogOptions) => Promise<boolean>
-
-    const App = defineComponent({
-      setup() {
-        ;({ openConfirmDialog } = useConfirmDialog(Dialog, '#dialog-2'))
-        return () => h('div')
-      },
-    })
-
-    const root = document.createElement('div')
-    document.body.appendChild(root)
-
-    createApp(App).mount(root)
-
-    await expect(openConfirmDialog(options)).rejects.toThrow('Provided component does not expose an "open" method')
-  })
-})