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

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,76 +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 { BodyContract } from '../../../../src/requests/contracts/BodyContract'
-
-const createBody = (content: string): BodyContract => ({
-  getHeaders: () => ({ 'Content-Type': 'application/json' }),
-  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('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,178 +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 { BodyContract } from '../../../../src/requests/contracts/BodyContract'
-
-const createBody = (content: string): BodyContract => ({
-  getHeaders: () => ({ 'Content-Type': 'application/json' }),
-  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('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')
-  })
-})

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

@@ -1,126 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { createApp, defineComponent, h, type Component } from 'vue'
-import useGlobalCheckbox from '../../../src/vue/composables/useGlobalCheckbox'
-
-const setupComposable = <T>(dialog: Component, options: { getAll: () => Promise<T[]>; getPage: () => T[]; totalCount: () => number }, targetId: string) => {
-  const dialogTarget = document.createElement('div')
-  dialogTarget.id = targetId
-  document.body.appendChild(dialogTarget)
-
-  let api: ReturnType<typeof useGlobalCheckbox<T>> | undefined
-
-  const App = defineComponent({
-    setup() {
-      api = useGlobalCheckbox<T>(dialog, options, `#${targetId}`)
-      return () => h('div')
-    },
-  })
-
-  const root = document.createElement('div')
-  document.body.appendChild(root)
-  createApp(App).mount(root)
-
-  return api!
-}
-
-const createEvent = () => {
-  const input = document.createElement('input')
-  const event = new Event('change') as Event & { target: HTMLInputElement; preventDefault: () => void }
-  Object.defineProperty(event, 'target', { value: input })
-  event.preventDefault = vi.fn()
-  return event
-}
-
-describe('useGlobalCheckbox', () => {
-  it('selects current page when all elements are on page', async () => {
-    const Dialog = defineComponent({
-      setup(_, { expose }) {
-        expose({ open: Promise.resolve(true) })
-        return () => h('div')
-      },
-    })
-
-    const options = {
-      getAll: vi.fn().mockResolvedValue([1, 2]),
-      getPage: vi.fn().mockReturnValue([1, 2]),
-      totalCount: vi.fn().mockReturnValue(2),
-    }
-
-    const api = setupComposable<number>(Dialog, options, 'dialog-all')
-
-    await api.handleGlobalCheckboxChange(createEvent())
-
-    expect(api.selectedRows.value).toEqual([1, 2])
-  })
-
-  it('opens dialog to select all when not all elements are on page', async () => {
-    const Dialog = defineComponent({
-      setup(_, { expose }) {
-        expose({ open: Promise.resolve(true) })
-        return () => h('div')
-      },
-    })
-
-    const options = {
-      getAll: vi.fn().mockResolvedValue([1, 2, 3]),
-      getPage: vi.fn().mockReturnValue([1]),
-      totalCount: vi.fn().mockReturnValue(3),
-    }
-
-    const api = setupComposable<number>(Dialog, options, 'dialog-select-all')
-    const event = createEvent()
-
-    await api.handleGlobalCheckboxChange(event)
-
-    expect(event.preventDefault).toHaveBeenCalled()
-    expect(api.selectedRows.value).toEqual([1, 2, 3])
-  })
-
-  it('clears selection on indeterminate cancel', async () => {
-    const Dialog = defineComponent({
-      setup(_, { expose }) {
-        expose({ open: Promise.resolve(false) })
-        return () => h('div')
-      },
-    })
-
-    const options = {
-      getAll: vi.fn().mockResolvedValue([1, 2, 3]),
-      getPage: vi.fn().mockReturnValue([1]),
-      totalCount: vi.fn().mockReturnValue(3),
-    }
-
-    const api = setupComposable<number>(Dialog, options, 'dialog-cancel')
-    api.selectedRows.value = [1]
-
-    await api.handleGlobalCheckboxChange(createEvent())
-
-    expect(api.selectedRows.value).toEqual([])
-  })
-
-  it('clears selection when already checked', async () => {
-    const Dialog = defineComponent({
-      setup(_, { expose }) {
-        expose({ open: Promise.resolve(true) })
-        return () => h('div')
-      },
-    })
-
-    const options = {
-      getAll: vi.fn().mockResolvedValue([1, 2]),
-      getPage: vi.fn().mockReturnValue([1, 2]),
-      totalCount: vi.fn().mockReturnValue(2),
-    }
-
-    const api = setupComposable<number>(Dialog, options, 'dialog-checked')
-    api.selectedRows.value = [1, 2]
-
-    await api.handleGlobalCheckboxChange(createEvent())
-
-    expect(api.selectedRows.value).toEqual([])
-
-    api.selectedRows.value = [1]
-    api.checked.value = false
-    expect(api.selectedRows.value).toEqual([])
-  })
-})

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

@@ -1,18 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import useIsEmpty from '../../../src/vue/composables/useIsEmpty'
-
-describe('useIsEmpty', () => {
-  it('detects empty values', () => {
-    const { isEmpty, isNotEmpty } = useIsEmpty()
-
-    expect(isEmpty(undefined)).toBe(true)
-    expect(isEmpty(null)).toBe(true)
-    expect(isEmpty('')).toBe(true)
-    expect(isEmpty([])).toBe(true)
-    expect(isEmpty({})).toBe(true)
-
-    expect(isNotEmpty('a')).toBe(true)
-    expect(isNotEmpty([1])).toBe(true)
-    expect(isNotEmpty({ a: 1 })).toBe(true)
-  })
-})

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

@@ -1,25 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import useIsOpen from '../../../src/vue/composables/useIsOpen'
-
-describe('useIsOpen', () => {
-  it('tracks open state and increments key after delay', () => {
-    vi.useFakeTimers()
-
-    const callback = vi.fn()
-    const { isOpen, isOpenKey } = useIsOpen(callback, 50)
-
-    isOpen.value = true
-    expect(isOpen.value).toBe(true)
-    expect(callback).toHaveBeenCalledWith(true)
-
-    isOpen.value = false
-    expect(isOpen.value).toBe(false)
-    expect(callback).toHaveBeenCalledWith(false)
-
-    expect(isOpenKey.value).toBe(0)
-    vi.advanceTimersByTime(50)
-    expect(isOpenKey.value).toBe(1)
-
-    vi.useRealTimers()
-  })
-})

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

@@ -1,22 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import useIsOpenFromVar from '../../../src/vue/composables/useIsOpenFromVar'
-
-describe('useIsOpenFromVar', () => {
-  it('syncs open state with variable and resets after delay', () => {
-    vi.useFakeTimers()
-
-    const { fromVar, isOpenFromVar, isOpenFromVarKey } = useIsOpenFromVar<string>('default', 50)
-
-    fromVar.value = 'value'
-    expect(isOpenFromVar.value).toBe(true)
-    expect(fromVar.value).toBe('value')
-
-    isOpenFromVar.value = false
-    vi.advanceTimersByTime(50)
-
-    expect(fromVar.value).toBe('default')
-    expect(isOpenFromVarKey.value).toBe(1)
-
-    vi.useRealTimers()
-  })
-})