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

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()
-  })
-})

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

@@ -1,30 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import useModelWrapper from '../../../src/vue/composables/useModelWrapper'
-
-describe('useModelWrapper', () => {
-  it('wraps modelValue and emits updates', () => {
-    const props = { modelValue: 1 }
-    const emit = vi.fn()
-    const callback = vi.fn()
-
-    const model = useModelWrapper<number, typeof emit>(props, emit, { callback })
-
-    expect(model.value).toBe(1)
-
-    model.value = 2
-
-    expect(emit).toHaveBeenCalledWith('update:modelValue', 2)
-    expect(callback).toHaveBeenCalledWith(2)
-  })
-
-  it('supports custom model name', () => {
-    const props = { custom: 'a' }
-    const emit = vi.fn()
-
-    const model = useModelWrapper<string, typeof emit>(props, emit, { name: 'custom' })
-
-    model.value = 'b'
-
-    expect(emit).toHaveBeenCalledWith('update:custom', 'b')
-  })
-})

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

@@ -1,26 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { ref, nextTick } from 'vue'
-import useOnOpen from '../../../src/vue/composables/useOnOpen'
-
-describe('useOnOpen', () => {
-  it('invokes open and close callbacks', async () => {
-    const isOpen = ref(false)
-    const { onOpen, onClose } = useOnOpen(isOpen)
-
-    const openCb = vi.fn()
-    const closeCb = vi.fn()
-
-    onOpen(openCb)
-    onClose(closeCb)
-
-    isOpen.value = true
-    await nextTick()
-    await nextTick()
-    expect(openCb).toHaveBeenCalledTimes(1)
-
-    isOpen.value = false
-    await nextTick()
-    await nextTick()
-    expect(closeCb).toHaveBeenCalledTimes(1)
-  })
-})

package/tests/vue/forms/BaseForm.behavior.test.ts

@@ -1,98 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { BaseForm, PropertyAwareArray } from '../../../src/vue/forms'
-import { RequiredRule, ValidationMode, type ValidationRules } from '../../../src/vue/forms/validation'
-
-interface TestFormState {
-  name: string
-  start_date: string
-  start_time: string
-  positions: PropertyAwareArray<{ value: string }>
-}
-
-class BehaviorForm extends BaseForm<TestFormState, TestFormState> {
-  protected override errorMap: { [serverKey: string]: string | string[] } = {
-    started_at: ['start_date', 'start_time']
-  }
-
-  public constructor() {
-    super(
-      {
-        name: '',
-        start_date: '',
-        start_time: '',
-        positions: new PropertyAwareArray([{ value: 'a' }])
-      },
-      { persist: false }
-    )
-  }
-
-  protected override defineRules(): ValidationRules<TestFormState> {
-    return {
-      name: {
-        rules: [new RequiredRule('Required')],
-        options: { mode: ValidationMode.PASSIVE }
-      }
-    }
-  }
-}
-
-describe('BaseForm behavior', () => {
-  it('tracks dirty and touched on simple fields', () => {
-    const form = new BehaviorForm()
-
-    expect(form.isDirty('name')).toBe(false)
-    expect(form.isTouched('name')).toBe(false)
-
-    form.properties.name.model.value = 'Alice'
-
-    expect(form.isDirty('name')).toBe(true)
-    expect(form.isTouched('name')).toBe(true)
-  })
-
-  it('tracks dirty state for PropertyAwareArray items', () => {
-    const form = new BehaviorForm()
-
-    const first = form.properties.positions[0]
-    expect(first.value.model.value).toBe('a')
-
-    first.value.model.value = 'b'
-
-    expect(form.properties.positions[0].value.dirty).toBe(true)
-    expect(form.isDirty('positions')).toBe(true)
-  })
-
-  it('maps external errors to fields and array items', () => {
-    const form = new BehaviorForm()
-
-    form.fillErrors({
-      name: ['Required'],
-      'positions.0.value': ['Invalid'],
-      started_at: ['Bad datetime']
-    })
-
-    expect(form.properties.name.errors).toEqual(['Required'])
-    expect(form.properties.positions[0].value.errors).toEqual(['Invalid'])
-    expect(form.properties.start_date.errors).toEqual(['Bad datetime'])
-    expect(form.properties.start_time.errors).toEqual(['Bad datetime'])
-  })
-
-  it('overwrites existing errors when fillErrors is called again', () => {
-    const form = new BehaviorForm()
-
-    form.fillErrors({ name: ['First'] })
-    form.fillErrors({ name: ['Second'] })
-
-    expect(form.properties.name.errors).toEqual(['Second'])
-  })
-
-  it('does not validate PASSIVE rules until validate(true) is called', () => {
-    const form = new BehaviorForm()
-
-    form.properties.name.model.value = ''
-    expect(form.properties.name.errors).toEqual([])
-
-    const ok = form.validate(true)
-    expect(ok).toBe(false)
-    expect(form.properties.name.errors.length).toBeGreaterThan(0)
-  })
-})

package/tests/vue/forms/BaseForm.transformers.test.ts

@@ -1,109 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { BaseForm } from '../../../src/vue/forms/BaseForm'
-
-type PositionsItem = { id: number; internal: string }
-
-interface TestFormState {
-  name: string
-  email: string | null
-  meta: { id: string; secret: string }
-  positions: PositionsItem[]
-  file: File | null
-}
-
-type TestRequestPayload = {
-  name?: string
-  email: string | null
-  meta: { id: string }
-  positions: Array<{ id: number }>
-  file?: File
-  started_at?: string
-}
-
-class TestForm extends BaseForm<TestRequestPayload, TestFormState> {
-  protected override append: string[] = ['started_at']
-
-  public constructor(overrides: Partial<TestFormState> = {}) {
-    super({
-      name: '',
-      email: null,
-      meta: { id: 'm1', secret: 'top-secret' },
-      positions: [
-        { id: 1, internal: 'x' },
-        { id: 2, internal: 'y' },
-      ],
-      file: null,
-      ...overrides,
-    }, { persist: false })
-  }
-
-  // Field getter: omit name if empty by returning undefined.
-  protected getName(value: string): string | undefined {
-    const trimmed = value.trim()
-    return trimmed.length ? trimmed : undefined
-  }
-
-  // Composite getter: omit nested meta.secret by returning undefined.
-  protected getMetaSecret(_value: string): undefined {
-    return undefined
-  }
-
-  // Composite getter: omit positions[].internal by returning undefined.
-  protected getPositionsInternal(_value: string): undefined {
-    return undefined
-  }
-
-  // Appended getter: omit started_at by returning undefined.
-  protected getStartedAt(): undefined {
-    return undefined
-  }
-}
-
-describe('BaseForm transformers / getters', () => {
-  it('omits top-level fields when a field getter returns undefined', () => {
-    const form = new TestForm({ name: '   ' })
-    const payload = form.buildPayload()
-
-    expect(Object.prototype.hasOwnProperty.call(payload, 'name')).toBe(false)
-    expect(payload).toMatchObject({
-      email: null,
-    })
-  })
-
-  it('keeps null values (only undefined omits)', () => {
-    const form = new TestForm({ name: 'Alice', email: null })
-    const payload = form.buildPayload()
-
-    expect(payload).toHaveProperty('name', 'Alice')
-    expect(payload).toHaveProperty('email', null)
-  })
-
-  it('omits nested properties when a composite getter returns undefined', () => {
-    const form = new TestForm({ name: 'Alice' })
-    const payload = form.buildPayload()
-
-    expect(payload.meta).toEqual({ id: 'm1' })
-  })
-
-  it('applies composite omission to arrays of objects', () => {
-    const form = new TestForm({ name: 'Alice' })
-    const payload = form.buildPayload()
-
-    expect(payload.positions).toEqual([{ id: 1 }, { id: 2 }])
-  })
-
-  it('omits appended fields when their getter returns undefined', () => {
-    const form = new TestForm({ name: 'Alice' })
-    const payload = form.buildPayload()
-
-    expect(Object.prototype.hasOwnProperty.call(payload, 'started_at')).toBe(false)
-  })
-
-  it('keeps File values intact (does not transform into a plain object)', () => {
-    const file = new File(['abc'], 'credentials.kdbx', { type: 'application/octet-stream' })
-    const form = new TestForm({ name: 'Alice', file })
-    const payload = form.buildPayload()
-
-    expect(payload.file).toBe(file)
-  })
-})

package/tests/vue/forms/PropertyAwareArray.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { PropertyAwareArray } from '../../../src/vue/forms/PropertyAwareArray'
-
-describe('PropertyAwareArray', () => {
-  it('creates from array and preserves type on map/filter/slice/concat', () => {
-    const arr = new PropertyAwareArray<number>([1, 2, 3])
-
-    const mapped = arr.map((value) => value * 2)
-    const filtered = arr.filter((value) => value > 1)
-    const sliced = arr.slice(1)
-    const concatenated = arr.concat([4])
-
-    expect(mapped).toBeInstanceOf(PropertyAwareArray)
-    expect(filtered).toBeInstanceOf(PropertyAwareArray)
-    expect(sliced).toBeInstanceOf(PropertyAwareArray)
-    expect(concatenated).toBeInstanceOf(PropertyAwareArray)
-
-    expect(mapped).toEqual([2, 4, 6])
-    expect(filtered).toEqual([2, 3])
-    expect(sliced).toEqual([2, 3])
-    expect(concatenated).toEqual([1, 2, 3, 4])
-  })
-
-  it('creates from arrayLike', () => {
-    const from = PropertyAwareArray.from({ 0: 'a', 1: 'b', length: 2 })
-
-    expect(from).toBeInstanceOf(PropertyAwareArray)
-    expect(from).toEqual(['a', 'b'])
-  })
-})

package/tests/vue/forms/validation/ValidationRules.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { RequiredRule } from '../../../../src/vue/forms/validation/rules/RequiredRule'
-import { EmailRule } from '../../../../src/vue/forms/validation/rules/EmailRule'
-import { MinRule } from '../../../../src/vue/forms/validation/rules/MinRule'
-import { UrlRule } from '../../../../src/vue/forms/validation/rules/UrlRule'
-import { ConfirmedRule } from '../../../../src/vue/forms/validation/rules/ConfirmedRule'
-import { JsonRule } from '../../../../src/vue/forms/validation/rules/JsonRule'
-import { ValidationMode } from '../../../../src/vue/forms/validation/ValidationMode.enum'
-
-describe('Validation rules', () => {
-  it('RequiredRule validates presence', () => {
-    const rule = new RequiredRule()
-
-    expect(rule.validate('')).toBe(false)
-    expect(rule.validate(null as unknown as string)).toBe(false)
-    expect(rule.validate(undefined as unknown as string)).toBe(false)
-    expect(rule.validate(0 as unknown as string)).toBe(true)
-    expect(rule.getMessage()).toBe('This field is required')
-  })
-
-  it('EmailRule validates email format', () => {
-    const rule = new EmailRule()
-
-    expect(rule.validate('')).toBe(true)
-    expect(rule.validate(123)).toBe(false)
-    expect(rule.validate('invalid')).toBe(false)
-    expect(rule.validate('test@example.com')).toBe(true)
-  })
-
-  it('MinRule validates numbers, strings, and arrays', () => {
-    const rule = new MinRule(3)
-
-    expect(rule.validate(null)).toBe(true)
-    expect(rule.validate('ab')).toBe(false)
-    expect(rule.validate('abc')).toBe(true)
-    expect(rule.validate(2)).toBe(false)
-    expect(rule.validate(3)).toBe(true)
-    expect(rule.validate([1, 2])).toBe(false)
-    expect(rule.validate([1, 2, 3])).toBe(true)
-    expect(rule.validate({})).toBe(false)
-    expect(rule.getMessage()).toBe('This field must be at least 3')
-  })
-
-  it('UrlRule validates URLs', () => {
-    const rule = new UrlRule()
-
-    expect(rule.validate('')).toBe(false)
-    expect(rule.validate('not a url')).toBe(false)
-    expect(rule.validate('https://example.com')).toBe(true)
-  })
-
-  it('ConfirmedRule validates matching fields', () => {
-    const rule = new ConfirmedRule<{ password: string; confirm: string }>('confirm')
-
-    expect(rule.dependsOn).toEqual(['confirm'])
-    expect(rule.getBidirectionalFields()).toEqual(['confirm'])
-
-    expect(rule.validate('', { password: '', confirm: '' })).toBe(true)
-    expect(rule.validate('a', { password: 'a', confirm: 'a' })).toBe(true)
-    expect(rule.validate('a', { password: 'a', confirm: 'b' })).toBe(false)
-  })
-
-  it('JsonRule validates JSON strings', () => {
-    const rule = new JsonRule()
-
-    expect(rule.validate('')).toBe(true)
-    expect(rule.validate('{"ok":true}')).toBe(true)
-    expect(rule.validate('{ bad }')).toBe(false)
-    expect(rule.validate(123)).toBe(false)
-  })
-
-  it('ValidationMode has combined flags', () => {
-    expect(ValidationMode.DEFAULT).toBe(ValidationMode.ON_TOUCH | ValidationMode.ON_DIRTY | ValidationMode.ON_SUBMIT)
-    expect(ValidationMode.AGGRESSIVE).toBe(
-      ValidationMode.INSTANTLY | ValidationMode.ON_TOUCH | ValidationMode.ON_DIRTY | ValidationMode.ON_SUBMIT
-    )
-    expect(ValidationMode.PASSIVE).toBe(ValidationMode.ON_SUBMIT)
-  })
-})

package/tests/vue/requests/VueRequestLoaders.test.ts

@@ -1,48 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { VueRequestLoader } from '../../../src/vue/requests/loaders/VueRequestLoader'
-import { VueRequestBatchLoader } from '../../../src/vue/requests/loaders/VueRequestBatchLoader'
-import { VueRequestLoaderFactory } from '../../../src/vue/requests/factories/VueRequestLoaderFactory'
-
-
-describe('Vue request loaders', () => {
-  it('VueRequestLoader tracks loading state', () => {
-    const loader = new VueRequestLoader()
-
-    expect(loader.isLoading().value).toBe(false)
-
-    loader.setLoading(true)
-    expect(loader.isLoading().value).toBe(true)
-
-    loader.setLoading(false)
-    expect(loader.isLoading().value).toBe(false)
-  })
-
-  it('VueRequestBatchLoader tracks batch state', () => {
-    const loader = new VueRequestBatchLoader(2)
-
-    expect(loader.isLoading().value).toBe(true)
-
-    loader.setLoading(true)
-    expect(loader.isLoading().value).toBe(true)
-
-    loader.setLoading(false)
-    expect(loader.isLoading().value).toBe(true)
-
-    loader.setLoading(false)
-    expect(loader.isLoading().value).toBe(false)
-
-    loader.startBatch(1)
-    expect(loader.isLoading().value).toBe(true)
-
-    loader.abortBatch()
-    expect(loader.isLoading().value).toBe(false)
-  })
-
-  it('VueRequestLoaderFactory creates a loader', () => {
-    const factory = new VueRequestLoaderFactory()
-
-    const loader = factory.make()
-
-    expect(loader.isLoading().value).toBe(false)
-  })
-})