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

package/tests/vue/router/routeResourceBinding/installRouteInjection.test.ts

@@ -1,450 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { installRouteInjection } from '../../../../src/vue/router/routeResourceBinding/installRouteInjection'
-
-/**
- * Flush all pending microtasks / promises.
- */
-function flushPromises() {
-  return new Promise<void>(resolve => setTimeout(resolve, 0))
-}
-
-/**
- * Minimal stub for vue-router's Router – we only need `beforeResolve`.
- */
-function createMockRouter() {
-  const guards: Array<(to: any) => Promise<void>> = []
-
-  return {
-    beforeResolve(guard: (to: any) => Promise<void>) {
-      guards.push(guard)
-    },
-    async simulateNavigation(to: any) {
-      for (const guard of guards) {
-        await guard(to)
-      }
-    }
-  }
-}
-
-function createRoute(params: Record<string, string>, matched: any[]) {
-  return {
-    params,
-    matched,
-    meta: {} as Record<string, any>
-  }
-}
-
-describe('installRouteInjection', () => {
-  let mockRouter: ReturnType<typeof createMockRouter>
-
-  beforeEach(() => {
-    mockRouter = createMockRouter()
-  })
-
-  it('resolves injected props and stores them in _injectedProps', async () => {
-    installRouteInjection(mockRouter as any)
-
-    const resolveFn = vi.fn().mockResolvedValue('resolved-invoice')
-
-    const to = createRoute({ invoiceId: '123' }, [
-      {
-        path: ':invoiceId',
-        meta: {
-          inject: {
-            invoice: {
-              from: 'invoiceId',
-              resolve: () => ({ resolve: resolveFn })
-            }
-          }
-        }
-      }
-    ])
-
-    await mockRouter.simulateNavigation(to)
-    await flushPromises()
-
-    expect(resolveFn).toHaveBeenCalledTimes(1)
-    expect(to.meta._injectedProps).toEqual({ invoice: 'resolved-invoice' })
-  })
-
-  it('reuses cached value when navigating to a child route with the same param', async () => {
-    installRouteInjection(mockRouter as any)
-
-    const resolveFn = vi.fn().mockResolvedValue('resolved-invoice')
-    const parentRecord = {
-      path: ':invoiceId',
-      meta: {
-        inject: {
-          invoice: {
-            from: 'invoiceId',
-            resolve: () => ({ resolve: resolveFn })
-          }
-        }
-      }
-    }
-
-    // First navigation: parent route
-    const to1 = createRoute({ invoiceId: '123' }, [parentRecord])
-    await mockRouter.simulateNavigation(to1)
-    await flushPromises()
-
-    expect(resolveFn).toHaveBeenCalledTimes(1)
-    expect(to1.meta._injectedProps).toEqual({ invoice: 'resolved-invoice' })
-
-    // Second navigation: parent + child route, same invoiceId
-    const to2 = createRoute({ invoiceId: '123' }, [
-      parentRecord,
-      { path: 'details', meta: {} }
-    ])
-    await mockRouter.simulateNavigation(to2)
-    await flushPromises()
-
-    // resolve should NOT be called again – cached value reused
-    expect(resolveFn).toHaveBeenCalledTimes(1)
-    expect(to2.meta._injectedProps).toEqual({ invoice: 'resolved-invoice' })
-  })
-
-  it('re-resolves when param value changes', async () => {
-    installRouteInjection(mockRouter as any)
-
-    const resolveFn = vi.fn()
-      .mockResolvedValueOnce('invoice-A')
-      .mockResolvedValueOnce('invoice-B')
-
-    const makeParent = () => ({
-      path: ':invoiceId',
-      meta: {
-        inject: {
-          invoice: {
-            from: 'invoiceId',
-            resolve: () => ({ resolve: resolveFn })
-          }
-        }
-      }
-    })
-
-    // Navigate with invoiceId=1
-    const to1 = createRoute({ invoiceId: '1' }, [makeParent()])
-    await mockRouter.simulateNavigation(to1)
-    await flushPromises()
-
-    expect(resolveFn).toHaveBeenCalledTimes(1)
-    expect(to1.meta._injectedProps).toEqual({ invoice: 'invoice-A' })
-
-    // Navigate with invoiceId=2 – must re-resolve
-    const to2 = createRoute({ invoiceId: '2' }, [makeParent()])
-    await mockRouter.simulateNavigation(to2)
-    await flushPromises()
-
-    expect(resolveFn).toHaveBeenCalledTimes(2)
-    expect(to2.meta._injectedProps).toEqual({ invoice: 'invoice-B' })
-  })
-
-  it('refresh() bypasses cache and fetches fresh data', async () => {
-    installRouteInjection(mockRouter as any)
-
-    const resolveFn = vi.fn()
-      .mockResolvedValueOnce('old-data')
-      .mockResolvedValueOnce('fresh-data')
-
-    const to = createRoute({ invoiceId: '123' }, [
-      {
-        path: ':invoiceId',
-        meta: {
-          inject: {
-            invoice: {
-              from: 'invoiceId',
-              resolve: () => ({ resolve: resolveFn })
-            }
-          }
-        }
-      }
-    ])
-
-    await mockRouter.simulateNavigation(to)
-    await flushPromises()
-    expect(to.meta._injectedProps).toEqual({ invoice: 'old-data' })
-
-    // Manually refresh
-    await to.meta.refresh!('invoice')
-    expect(resolveFn).toHaveBeenCalledTimes(2)
-    expect(to.meta._injectedProps).toEqual({ invoice: 'fresh-data' })
-  })
-
-  it('evicts cache entries when navigating away from a route', async () => {
-    installRouteInjection(mockRouter as any)
-
-    const invoiceResolve = vi.fn().mockResolvedValue('invoice-data')
-    const productResolve = vi.fn().mockResolvedValue('product-data')
-
-    // Navigate to invoice route
-    const to1 = createRoute({ invoiceId: '1' }, [
-      {
-        path: ':invoiceId',
-        meta: {
-          inject: {
-            invoice: {
-              from: 'invoiceId',
-              resolve: () => ({ resolve: invoiceResolve })
-            }
-          }
-        }
-      }
-    ])
-    await mockRouter.simulateNavigation(to1)
-    await flushPromises()
-    expect(invoiceResolve).toHaveBeenCalledTimes(1)
-
-    // Navigate to a completely different route (product)
-    const to2 = createRoute({ productId: '5' }, [
-      {
-        path: ':productId',
-        meta: {
-          inject: {
-            product: {
-              from: 'productId',
-              resolve: () => ({ resolve: productResolve })
-            }
-          }
-        }
-      }
-    ])
-    await mockRouter.simulateNavigation(to2)
-    await flushPromises()
-
-    // Now navigate back to invoice with the same id – should re-resolve (cache was evicted)
-    const to3 = createRoute({ invoiceId: '1' }, [
-      {
-        path: ':invoiceId',
-        meta: {
-          inject: {
-            invoice: {
-              from: 'invoiceId',
-              resolve: () => ({ resolve: invoiceResolve })
-            }
-          }
-        }
-      }
-    ])
-    await mockRouter.simulateNavigation(to3)
-    await flushPromises()
-    expect(invoiceResolve).toHaveBeenCalledTimes(2)
-  })
-
-  it('child routes inherit parent injected props without re-resolving across multiple children', async () => {
-    installRouteInjection(mockRouter as any)
-
-    const resolveFn = vi.fn().mockResolvedValue('invoice-data')
-    const parentRecord = {
-      path: ':invoiceId',
-      meta: {
-        inject: {
-          invoice: {
-            from: 'invoiceId',
-            resolve: () => ({ resolve: resolveFn })
-          }
-        }
-      }
-    }
-
-    // Navigate to parent
-    await mockRouter.simulateNavigation(createRoute({ invoiceId: '42' }, [parentRecord]))
-    await flushPromises()
-    expect(resolveFn).toHaveBeenCalledTimes(1)
-
-    // Navigate to child A
-    const toChildA = createRoute({ invoiceId: '42' }, [parentRecord, { path: 'edit', meta: {} }])
-    await mockRouter.simulateNavigation(toChildA)
-    await flushPromises()
-    expect(resolveFn).toHaveBeenCalledTimes(1)
-    expect(toChildA.meta._injectedProps).toEqual({ invoice: 'invoice-data' })
-
-    // Navigate to child B
-    const toChildB = createRoute({ invoiceId: '42' }, [parentRecord, { path: 'payments', meta: {} }])
-    await mockRouter.simulateNavigation(toChildB)
-    await flushPromises()
-    expect(resolveFn).toHaveBeenCalledTimes(1)
-    expect(toChildB.meta._injectedProps).toEqual({ invoice: 'invoice-data' })
-  })
-
-  it('sets loading state to true while resolving and false after', async () => {
-    installRouteInjection(mockRouter as any)
-
-    let resolvePromise: (value: string) => void
-    const resolveFn = vi.fn().mockImplementation(() => {
-      return new Promise<string>((resolve) => {
-        resolvePromise = resolve
-      })
-    })
-
-    const to = createRoute({ invoiceId: '123' }, [
-      {
-        path: ':invoiceId',
-        meta: {
-          inject: {
-            invoice: {
-              from: 'invoiceId',
-              resolve: () => ({ resolve: resolveFn })
-            }
-          }
-        }
-      }
-    ])
-
-    await mockRouter.simulateNavigation(to)
-
-    // Loading should be true while the resolver is pending
-    const state = to.meta._injectionState as Record<string, { loading: boolean; error: Error | null }>
-    expect(state.invoice.loading).toBe(true)
-    expect(state.invoice.error).toBeNull()
-
-    // Resolve the promise
-    resolvePromise!('resolved-invoice')
-    await flushPromises()
-
-    // Loading should be false after resolution
-    expect(state.invoice.loading).toBe(false)
-    expect(state.invoice.error).toBeNull()
-    expect(to.meta._injectedProps).toEqual({ invoice: 'resolved-invoice' })
-  })
-
-  it('sets error state when resolver fails', async () => {
-    installRouteInjection(mockRouter as any)
-
-    const resolveFn = vi.fn().mockRejectedValue(new Error('Network error'))
-
-    const to = createRoute({ invoiceId: '123' }, [
-      {
-        path: ':invoiceId',
-        meta: {
-          inject: {
-            invoice: {
-              from: 'invoiceId',
-              resolve: () => ({ resolve: resolveFn })
-            }
-          }
-        }
-      }
-    ])
-
-    await mockRouter.simulateNavigation(to)
-    await flushPromises()
-
-    const state = to.meta._injectionState as Record<string, { loading: boolean; error: Error | null }>
-    expect(state.invoice.loading).toBe(false)
-    expect(state.invoice.error).toBeInstanceOf(Error)
-    expect(state.invoice.error!.message).toBe('Network error')
-  })
-
-  it('navigation is non-blocking (guard returns before resolvers complete)', async () => {
-    installRouteInjection(mockRouter as any)
-
-    let resolvePromise: (value: string) => void
-    const resolveFn = vi.fn().mockImplementation(() => {
-      return new Promise<string>((resolve) => {
-        resolvePromise = resolve
-      })
-    })
-
-    const to = createRoute({ invoiceId: '123' }, [
-      {
-        path: ':invoiceId',
-        meta: {
-          inject: {
-            invoice: {
-              from: 'invoiceId',
-              resolve: () => ({ resolve: resolveFn })
-            }
-          }
-        }
-      }
-    ])
-
-    // simulateNavigation should return even though the resolver hasn't completed
-    await mockRouter.simulateNavigation(to)
-
-    // Props should NOT be set yet (resolver still pending)
-    expect((to.meta._injectedProps as any).invoice).toBeUndefined()
-
-    // Now resolve
-    resolvePromise!('resolved-invoice')
-    await flushPromises()
-
-    expect(to.meta._injectedProps).toEqual({ invoice: 'resolved-invoice' })
-  })
-
-  it('refresh() with silent option does not set loading state', async () => {
-    installRouteInjection(mockRouter as any)
-
-    const resolveFn = vi.fn()
-      .mockResolvedValueOnce('old-data')
-      .mockResolvedValueOnce('fresh-data')
-
-    const to = createRoute({ invoiceId: '123' }, [
-      {
-        path: ':invoiceId',
-        meta: {
-          inject: {
-            invoice: {
-              from: 'invoiceId',
-              resolve: () => ({ resolve: resolveFn })
-            }
-          }
-        }
-      }
-    ])
-
-    await mockRouter.simulateNavigation(to)
-    await flushPromises()
-    expect(to.meta._injectedProps).toEqual({ invoice: 'old-data' })
-
-    const state = to.meta._injectionState as Record<string, { loading: boolean; error: Error | null }>
-
-    // Track loading state changes during silent refresh
-    let loadingWasTrue = false
-    const checkLoading = setInterval(() => {
-      if (state.invoice.loading) loadingWasTrue = true
-    }, 0)
-
-    await to.meta.refresh!('invoice', { silent: true })
-
-    clearInterval(checkLoading)
-    expect(loadingWasTrue).toBe(false)
-    expect(state.invoice.loading).toBe(false)
-    expect(to.meta._injectedProps).toEqual({ invoice: 'fresh-data' })
-  })
-
-  it('refresh() resets loading and error state', async () => {
-    installRouteInjection(mockRouter as any)
-
-    const resolveFn = vi.fn()
-      .mockRejectedValueOnce(new Error('First fail'))
-      .mockResolvedValueOnce('success-data')
-
-    const to = createRoute({ invoiceId: '123' }, [
-      {
-        path: ':invoiceId',
-        meta: {
-          inject: {
-            invoice: {
-              from: 'invoiceId',
-              resolve: () => ({ resolve: resolveFn })
-            }
-          }
-        }
-      }
-    ])
-
-    await mockRouter.simulateNavigation(to)
-    await flushPromises()
-
-    const state = to.meta._injectionState as Record<string, { loading: boolean; error: Error | null }>
-    expect(state.invoice.error).toBeInstanceOf(Error)
-
-    // Refresh should clear the error and resolve successfully
-    await to.meta.refresh!('invoice')
-    expect(state.invoice.loading).toBe(false)
-    expect(state.invoice.error).toBeNull()
-    expect(to.meta._injectedProps).toEqual({ invoice: 'success-data' })
-  })
-})

package/tests/vue/state/State.test.ts

@@ -1,151 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { nextTick } from 'vue'
-import { State } from '../../../src/vue/state/State'
-import type { PersistenceDriver } from '../../../src/persistenceDrivers/types/PersistenceDriver'
-
-class MemoryDriver implements PersistenceDriver {
-  public store = new Map<string, unknown>()
-
-  get<T>(key: string): T | null {
-    return (this.store.get(key) as T) ?? null
-  }
-
-  set<T>(key: string, state: T): void {
-    this.store.set(key, state)
-  }
-
-  remove(key: string): void {
-    this.store.delete(key)
-  }
-}
-
-let driver: MemoryDriver
-
-class TestState extends State<{ count: number; nested: { value: string }; items: number[] }> {
-  protected getPersistenceDriver(): PersistenceDriver {
-    return driver
-  }
-}
-
-describe('State', () => {
-  beforeEach(() => {
-    driver = new MemoryDriver()
-  })
-
-  it('exposes proxy access and deep exports', () => {
-    const state = new TestState({ count: 1, nested: { value: 'a' }, items: [1] })
-
-    state.state.count = 2
-    expect(state.state.count).toBe(2)
-
-    const exported = state.export()
-    exported.nested.value = 'changed'
-
-    expect(state.state.nested.value).toBe('a')
-  })
-
-  it('imports values and persists when enabled', () => {
-    const state = new TestState(
-      { count: 1, nested: { value: 'a' }, items: [1] },
-      { persist: true }
-    )
-
-    state.import({ count: 5 })
-
-    expect(state.state.count).toBe(5)
-    expect(driver.get(state.persistKey)).toEqual({ count: 5, nested: { value: 'a' }, items: [1] })
-  })
-
-  it('loads persisted values when keys match', () => {
-    driver.set('TestState', { count: 9, nested: { value: 'persisted' }, items: [2] })
-
-    const state = new TestState({ count: 1, nested: { value: 'a' }, items: [1] }, { persist: true })
-
-    expect(state.state.count).toBe(9)
-    expect(state.state.nested.value).toBe('persisted')
-    expect(state.state.items).toEqual([2])
-  })
-
-  it('clears persisted values when keys mismatch', () => {
-    driver.set('TestState', { count: 9 })
-
-    const state = new TestState({ count: 1, nested: { value: 'a' }, items: [1] }, { persist: true })
-
-    expect(driver.get(state.persistKey)).toBeNull()
-    expect(state.state.count).toBe(1)
-  })
-
-  it('subscribes to top-level and nested changes', async () => {
-    const state = new TestState({ count: 1, nested: { value: 'a' }, items: [] })
-
-    const countHandler = vi.fn()
-    const nestedHandler = vi.fn()
-
-    const stopCount = state.subscribe('count', countHandler)
-    const stopNested = state.subscribe('nested.value', nestedHandler)
-
-    state.state.count = 2
-    state.state.nested.value = 'b'
-
-    await nextTick()
-
-    expect(countHandler).toHaveBeenCalledTimes(1)
-    expect(nestedHandler).toHaveBeenCalledTimes(1)
-
-    stopCount()
-    stopNested()
-
-    state.state.count = 3
-    await nextTick()
-    expect(countHandler).toHaveBeenCalledTimes(1)
-  })
-
-  it('supports array path subscriptions and reset handlers', async () => {
-    const state = new TestState({ count: 1, nested: { value: 'a' }, items: [] })
-
-    const handler = vi.fn()
-    state.subscribe(['count', 'nested.value'], handler, { executeOnReset: true })
-
-    state.reset()
-
-    await nextTick()
-
-    const calls = handler.mock.calls.map((call) => call[0])
-    expect(calls).toContain('count')
-    expect(calls).toContain('nested.value')
-  })
-
-  it('debounces change handlers', async () => {
-    vi.useFakeTimers()
-
-    const state = new TestState({ count: 1, nested: { value: 'a' }, items: [] })
-    const handler = vi.fn()
-
-    state.subscribe('count', handler, { debounce: 50 })
-    state.state.count = 2
-
-    await nextTick()
-    expect(handler).not.toHaveBeenCalled()
-
-    vi.advanceTimersByTime(50)
-    await nextTick()
-
-    expect(handler).toHaveBeenCalledTimes(1)
-
-    vi.useRealTimers()
-  })
-
-  it('destroys watchers and clears internal state', async () => {
-    const state = new TestState({ count: 1, nested: { value: 'a' }, items: [] })
-    const handler = vi.fn()
-
-    state.subscribe('count', handler)
-
-    state.destroy()
-
-    state.state.count = 2
-    await nextTick()
-
-    expect(handler).not.toHaveBeenCalled()
-  })
-})