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

package/src/vue/router/routeResourceBinding/installRouteInjection.ts

@@ -1,164 +0,0 @@
-import { type Router } from 'vue-router'
-import { reactive } from 'vue'
-
-type InjectRuntimeConfig = {
-  from: string
-  resolve: (param: string) => { resolve(): Promise<unknown> }
-  getter: (payload: unknown) => unknown
-}
-
-type CachedEntry = {
-  paramValue: string
-  payload: unknown
-}
-
-/**
- * Installs the runtime part:
- * - resolves all route.inject entries before navigation completes
- * - stores results on to.meta._injectedProps
- * - ensures route props include injected results (so components receive them as props)
- * - caches resolved resources so child routes inherit parent-resolved data
- *   without triggering redundant requests (as long as the param value is unchanged)
- *
- * Notes:
- * - This keeps router files clean: only an `inject` block per route.
- * - This is intentionally runtime-generic; type safety happens at route definition time.
- */
-export function installRouteInjection(router: Router) {
-  const cache: Record<string, CachedEntry> = {}
-
-  router.beforeResolve(async (to) => {
-    console.log('[Route Injection] Resolving route injections...')
-
-    if (!to.meta._injectedProps) {
-      to.meta._injectedProps = reactive({})
-    }
-
-    if (!to.meta._injectionState) {
-      to.meta._injectionState = reactive({})
-    }
-
-    const resolvers: Record<string, (options?: { silent?: boolean }) => Promise<unknown>> = {}
-    const activePropNames = new Set<string>()
-    const pendingResolvers: Array<() => Promise<void>> = []
-
-    // Iterate through all matched route records (from parent to child)
-    for (const record of to.matched) {
-      console.debug(`[Route Injection] Processing route "${record.path}"`)
-
-      // Access the custom 'inject' property directly from the record
-      const inject = record.meta.inject as Record<string, InjectRuntimeConfig> | undefined
-
-      if (!inject) {
-        console.debug(`[Route Injection] No injections found for route "${record.path}"`)
-
-        continue
-      }
-
-      for (const [propName, cfg] of Object.entries(inject)) {
-        const rawParam = to.params[cfg.from]
-
-        if (rawParam === undefined || rawParam === null) {
-          console.warn(`[Route Injection] Param "${cfg.from}" not found for prop "${propName}"`)
-
-          continue
-        }
-
-        const paramValue = Array.isArray(rawParam) ? rawParam[0] : String(rawParam)
-
-        if (paramValue === undefined || paramValue === null) {
-          console.warn(`[Route Injection] Param value "${cfg.from}" not found for prop "${propName}"`)
-
-          continue
-        }
-
-        activePropNames.add(propName)
-
-        // Initialize state for this prop
-        const state = to.meta._injectionState as Record<string, { loading: boolean; error: Error | null }>
-        if (!state[propName]) {
-          state[propName] = reactive({ loading: false, error: null })
-        }
-
-        // Define the refresh logic for this specific prop (always fetches fresh data)
-        const resolveProp = async (options?: { silent?: boolean }) => {
-          const propState = (to.meta._injectionState as Record<string, { loading: boolean; error: Error | null }>)[propName]!
-          if (!options?.silent) {
-            propState.loading = true
-          }
-          propState.error = null
-
-          try {
-            const resolver = cfg.resolve(paramValue)
-            let payload = await resolver.resolve()
-            if (typeof cfg.getter === 'function') {
-              payload = cfg.getter(payload)
-            }
-
-            // Update cache
-            cache[propName] = { paramValue, payload }
-
-            // Updating the reactive object triggers the component re-render
-            const injectedProps = to.meta._injectedProps as Record<string, unknown>
-            injectedProps[propName] = payload
-            return payload
-          } catch (e) {
-            propState.error = e instanceof Error ? e : new Error(String(e))
-            throw e
-          } finally {
-            propState.loading = false
-          }
-        }
-
-        resolvers[propName] = resolveProp
-
-        // Reuse cached value if the param hasn't changed (e.g. navigating between child routes)
-        const cached = cache[propName]
-        if (cached && cached.paramValue === paramValue) {
-          console.debug(`[Route Injection] Using cached value for prop "${propName}" (param "${cfg.from}" unchanged)`)
-          const injectedPropsCache = to.meta._injectedProps as Record<string, unknown>
-          injectedPropsCache[propName] = cached.payload
-
-          continue
-        }
-
-        // Set loading immediately and queue resolver (non-blocking)
-        const injectionState = to.meta._injectionState as Record<string, { loading: boolean; error: Error | null }>
-        injectionState[propName]!.loading = true
-        pendingResolvers.push(async () => {
-          try {
-            await resolveProp()
-          } catch (e) {
-            console.error(`[Route Injection] Failed to resolve prop "${propName}"`, e)
-          }
-        })
-
-        console.debug(`[Route Injection] Queued resolution for prop "${propName}" for route "${record.path}"`)
-      }
-    }
-
-    // Evict cache entries that are no longer part of the active route hierarchy
-    for (const key of Object.keys(cache)) {
-      if (!activePropNames.has(key)) {
-        delete cache[key]
-      }
-    }
-
-    // Attach the resolvers and a global refresh helper to the route meta
-    to.meta['_injectedResolvers'] = resolvers
-    to.meta['refresh'] = async (propName: string, options?: { silent?: boolean }) => {
-      if (resolvers[propName]) {
-        return await resolvers[propName](options)
-      }
-
-      console.warn(`[Route Injection] No resolver found for "${propName}"`)
-
-      return undefined
-    }
-
-    // Fire pending resolvers without blocking navigation
-    if (pendingResolvers.length > 0) {
-      Promise.all(pendingResolvers.map((fn) => fn()))
-    }
-  })
-}

package/src/vue/router/routeResourceBinding/types.ts

@@ -1,53 +0,0 @@
-import { type Component } from 'vue'
-import { type RouteLocationNormalized } from 'vue-router'
-
-/**
- * Generic resolver interface.
- */
-export interface Resolver<T> {
-  resolve(): Promise<T>
-}
-
-/**
- * A minimal "request" contract that matches your request classes:
- * new ProductShowRequest(id).send() -> { getData(): T }
- */
-export interface DataRequest<T> {
-  send(): Promise<{ getData(): T }>
-}
-
-/**
- * Inject config that is type-safe against component props.
- *
- * Props[K] is the required resolved type for prop K.
- */
-export type InjectConfig<Props extends Record<string, unknown>> = {
-  [K in keyof Props]?: {
-    /**
-     * Route param name, e.g. "productId"
-     */
-    from: keyof RouteLocationNormalized['params'] | string
-
-    /**
-     * Create a resolver from the param value.
-     * Param value is treated as string (most common in routes).
-     */
-    resolve: (param: string) => Resolver<Props[K]>
-  }
-}
-
-/**
- * Extended route meta to store injected props at runtime.
- */
-declare module 'vue-router' {
-  interface RouteMeta {
-    _injectedProps?: Record<string, unknown>
-    _injectedResolvers?: Record<string, () => Promise<unknown>>
-    _injectionState?: Record<string, { loading: boolean; error: Error | null }>
-    _errorComponent?: Component
-    _loadingComponent?: Component
-    _lazy?: boolean
-    refresh?: (propName: string, options?: { silent?: boolean }) => Promise<unknown>
-    inject?: Record<string, unknown>
-  }
-}

package/src/vue/router/routeResourceBinding/useRouteResource.ts

@@ -1,24 +0,0 @@
-import { computed, type ComputedRef } from 'vue'
-import { useRoute } from 'vue-router'
-
-type InjectionState = Record<string, { loading: boolean; error: Error | null }>
-
-export function useRouteResource(propName: string) {
-  const route = useRoute()
-
-  const refresh = async (options?: { silent?: boolean }) => {
-    return await route.meta.refresh?.(propName, options)
-  }
-
-  const isLoading: ComputedRef<boolean> = computed(() => {
-    const state = route.meta._injectionState as InjectionState | undefined
-    return state?.[propName]?.loading ?? false
-  })
-
-  const error: ComputedRef<Error | null> = computed(() => {
-    const state = route.meta._injectionState as InjectionState | undefined
-    return state?.[propName]?.error ?? null
-  })
-
-  return { refresh, isLoading, error }
-}

package/src/vue/state/State.ts

@@ -1,380 +0,0 @@
-import { debounce } from 'lodash-es'
-import { type PersistenceDriver } from '../../persistenceDrivers'
-import { NonPersistentDriver } from '../../persistenceDrivers'
-import { computed, ref, type Ref, watch, reactive } from 'vue'
-
-export interface StateOptions {
-  persist?: boolean
-  persistSuffix?: string
-}
-
-/** Generic type for change handlers. */
-type ChangeHandler<T> = (val: T, oldVal: T) => void
-
-/** Type for accessing nested properties with dot notation. */
-type PathValue<T, P extends string> = P extends keyof T
-  ? T[P]
-  : P extends `${infer K}.${infer Rest}`
-    ? K extends keyof T
-      ? T[K] extends Record<string, unknown>
-        ? PathValue<T[K], Rest>
-        : never
-      : never
-    : never
-
-/** Helper type to get all possible paths in an object. */
-type PathsToStringProps<T> = T extends object ? { [K in keyof T]: K extends string ? K | `${K}.${PathsToStringProps<T[K]>}` : never }[keyof T] : never
-
-/** Union type of all possible dot-notation paths in T. */
-type Path<T> = keyof T | PathsToStringProps<T>
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === 'object' && !Array.isArray(value)
-}
-
-function getNestedValue(root: unknown, pathParts: string[]): unknown {
-  let current = root
-  for (const part of pathParts) {
-    if (!isRecord(current)) {
-      return undefined
-    }
-    current = current[part]
-  }
-  return current
-}
-
-export abstract class State<T extends object> {
-  private readonly properties: { [K in keyof T]: Ref<T[K]> }
-  private readonly _initial: T
-  private readonly _persist: boolean
-  private readonly _persistKey: string
-  private _driver: PersistenceDriver
-  private _stateProxy: T | null = null
-  private _watchStopFunctions: Map<string, () => void> = new Map()
-  private _resetHandlers: Map<string, (() => void)[]> = new Map()
-  private _watchIdCounter = 0
-
-  protected constructor(initial: T, options?: StateOptions) {
-    this._initial = initial
-    this._persist = !!options?.persist
-    const className = this.constructor.name
-    this._persistKey = className + (options?.persistSuffix ? `_${options.persistSuffix}` : '')
-    this._driver = this.getPersistenceDriver()
-
-    let loaded: T | null = null
-    if (this._persist) {
-      loaded = this._driver.get<T>(this._persistKey)
-      if (loaded) {
-        const initialKeys = Object.keys(initial).sort()
-        const loadedKeys = Object.keys(loaded).sort()
-        const sameKeys = initialKeys.length === loadedKeys.length && initialKeys.every((k, i) => k === loadedKeys[i])
-        if (!sameKeys) {
-          this._driver.remove(this._persistKey)
-          loaded = null
-        }
-      }
-    }
-
-    const base = loaded ?? initial
-    this.properties = {} as { [K in keyof T]: Ref<T[K]> }
-    const keys = Object.keys(base) as Array<keyof T>
-
-    for (const k of keys) {
-      let value = (base as T)[k]
-      value = this.wrapReactive(value)
-
-      const _ref = ref(value) as Ref<T[typeof k]>
-
-      this.properties[k] = computed({
-        get: () => _ref.value,
-        set: (val) => {
-          _ref.value = this.wrapReactive(val)
-
-          if (this._persist) {
-            this._driver.set(this._persistKey, this.export())
-          }
-        }
-      }) as Ref<T[typeof k]>
-    }
-  }
-
-  /**
-   * Safe deep clone that preserves types
-   */
-  private deepClone<V>(value: V): V {
-    if (value === null || value === undefined) return value
-    if (typeof value !== 'object') return value
-
-    return JSON.parse(JSON.stringify(value)) as V
-  }
-
-  /**
-   * Ensure objects/arrays are cloned and wrapped in Vue reactivity.
-   */
-  private wrapReactive<V>(value: V): V {
-    if (value && typeof value === 'object') {
-      return reactive(this.deepClone(value)) as V
-    }
-    return value
-  }
-
-  /**
-   * Get a proxy to the state that allows direct property access and setting
-   * without using .value
-   */
-  public get state(): T {
-    if (!this._stateProxy) {
-      this._stateProxy = new Proxy({} as T, {
-        get: (_, prop: string | symbol) => {
-          if (typeof prop === 'symbol' || prop === 'toJSON') {
-            return undefined
-          }
-
-          const key = prop as keyof T
-          if (key in this.properties) {
-            return this.properties[key].value
-          }
-
-          return undefined
-        },
-        set: (_, prop: string | symbol, value) => {
-          if (typeof prop === 'symbol') {
-            return false
-          }
-
-          const key = prop as keyof T
-          if (key in this.properties) {
-            this.properties[key].value = value
-          }
-
-          return true
-        }
-      })
-    }
-
-    return this._stateProxy
-  }
-
-  /**
-   * Add a subscription to specific properties or nested properties
-   * @param paths Path(s) to the property. Can be:
-   *              - A single path (top-level key or nested with dot notation)
-   *              - An array of paths to watch (triggers when any changes)
-   * @param handler Function to call when the property changes
-   * @param options Optional configuration for debounce and executeOnReset
-   * @returns A function to remove the subscription
-   */
-  public subscribe<P extends Path<T>>(
-    paths: P,
-    handler: ChangeHandler<PathValue<T, P & string>>,
-    options?: { debounce?: number; executeOnReset?: boolean }
-  ): () => void
-  public subscribe<P extends Path<T>>(
-    paths: P[],
-    handler: (changedPath: P, state: T) => void,
-    options?: { debounce?: number; executeOnReset?: boolean }
-  ): () => void
-  public subscribe<P extends Path<T>>(
-    paths: P | P[],
-    handler: ChangeHandler<PathValue<T, P & string>> | ((changedPath: P, state: T) => void),
-    options?: { debounce?: number; executeOnReset?: boolean }
-  ): () => void {
-    const stopFunctions: (() => void)[] = []
-    const resetHandlers: (() => void)[] = []
-
-    if (Array.isArray(paths)) {
-      for (const path of paths) {
-        const pathHandler = () => {
-          ;(handler as (changedPath: P, state: T) => void)(path, this.export())
-        }
-
-        if (options?.executeOnReset) {
-          resetHandlers.push(pathHandler)
-        }
-
-        const stop = this.setupWatcher(path as string, pathHandler, options)
-        stopFunctions.push(stop)
-      }
-    } else {
-      const pathHandler = handler as ChangeHandler<unknown>
-
-      if (options?.executeOnReset) {
-        resetHandlers.push(() => pathHandler(undefined, undefined))
-      }
-
-      const stop = this.setupWatcher(paths as string, pathHandler, options)
-      stopFunctions.push(stop)
-    }
-
-    if (resetHandlers.length > 0) {
-      const resetId = Math.random().toString(36)
-      this._resetHandlers.set(resetId, resetHandlers)
-
-      stopFunctions.push(() => {
-        this._resetHandlers.delete(resetId)
-      })
-    }
-
-    return () => stopFunctions.forEach((stop) => stop())
-  }
-
-  /**
-   * Internal method to set up a watcher for a specific path
-   */
-  private setupWatcher(
-    path: string,
-    handler: (newVal?: unknown, oldVal?: unknown) => void,
-    options?: { debounce?: number; executeOnReset?: boolean }
-  ): () => void {
-    const pathParts = path.split('.')
-    const debouncedHandler = options?.debounce && options.debounce > 0 ? debounce(handler, options.debounce) : undefined
-
-    const effectiveHandler = debouncedHandler || handler
-
-    if (pathParts.length === 1 && path in this.properties) {
-      const key = path as keyof T
-
-      const stopWatch = watch(
-        () => this.properties[key].value,
-        (newVal, oldVal) => {
-          if (!this.isEqual(newVal, oldVal)) {
-            effectiveHandler(newVal, oldVal)
-          }
-        },
-        { deep: true }
-      )
-
-      const watchId = `watch:${this._watchIdCounter++}`
-      this._watchStopFunctions.set(watchId, stopWatch)
-
-      return () => {
-        if (this._watchStopFunctions.has(watchId)) {
-          this._watchStopFunctions.get(watchId)!()
-          this._watchStopFunctions.delete(watchId)
-        }
-      }
-    }
-
-    const topLevelKey = pathParts[0] as keyof T
-
-    if (topLevelKey in this.properties) {
-      const getter = () => {
-        const root = this.properties[topLevelKey].value
-        return getNestedValue(root, pathParts.slice(1))
-      }
-
-      const stopWatch = watch(
-        getter,
-        (newVal, oldVal) => {
-          if (!this.isEqual(newVal, oldVal)) {
-            effectiveHandler(newVal, oldVal)
-          }
-        },
-        { deep: true }
-      )
-
-      const watchId = `watch:${this._watchIdCounter++}`
-      this._watchStopFunctions.set(watchId, stopWatch)
-
-      return () => {
-        if (this._watchStopFunctions.has(watchId)) {
-          this._watchStopFunctions.get(watchId)!()
-          this._watchStopFunctions.delete(watchId)
-        }
-      }
-    }
-
-    return () => {}
-  }
-
-  /**
-   * Simple deep equality check
-   */
-  private isEqual(a: unknown, b: unknown): boolean {
-    if (a === b) return true
-
-    if (a === null || b === null) return false
-    if (a === undefined || b === undefined) return false
-
-    if (typeof a !== typeof b) return false
-
-    if (typeof a === 'object' && typeof b === 'object') {
-      const aArray = Array.isArray(a)
-      const bArray = Array.isArray(b)
-
-      if (aArray !== bArray) return false
-
-      if (aArray && bArray) {
-        const arrayA = a as unknown[]
-        const arrayB = b as unknown[]
-        if (arrayA.length !== arrayB.length) return false
-        return arrayA.every((val, i) => this.isEqual(val, arrayB[i]))
-      }
-
-      const objA = a as Record<string, unknown>
-      const objB = b as Record<string, unknown>
-
-      const keysA = Object.keys(objA).sort()
-      const keysB = Object.keys(objB).sort()
-
-      if (keysA.length !== keysB.length) return false
-      if (!keysA.every((k, i) => k === keysB[i])) return false
-
-      return keysA.every((k) => this.isEqual(objA[k], objB[k]))
-    }
-
-    return false
-  }
-
-  protected getPersistenceDriver(): PersistenceDriver {
-    return new NonPersistentDriver()
-  }
-
-  public export(): T {
-    const out = {} as T
-    for (const k in this.properties) {
-      const key = k as keyof T
-      out[key] = this.deepClone(this.properties[key].value)
-    }
-    return out
-  }
-
-  public import(data: Partial<T>): void {
-    for (const k in data) {
-      if (k in this.properties) {
-        const key = k as keyof T
-        this.properties[key].value = data[key] as T[typeof key]
-      }
-    }
-    if (this._persist) {
-      this._driver.set(this._persistKey, this.export())
-    }
-  }
-
-  public reset(): void {
-    this.import(this._initial)
-
-    for (const handlers of this._resetHandlers.values()) {
-      for (const handler of handlers) {
-        handler()
-      }
-    }
-  }
-
-  public get persistKey(): string {
-    return this._persistKey
-  }
-
-  /**
-   * Clean up all watchers when the state is no longer needed
-   */
-  public destroy(): void {
-    for (const stopFn of this._watchStopFunctions.values()) {
-      stopFn()
-    }
-    this._watchStopFunctions.clear()
-    this._resetHandlers.clear()
-
-    this._stateProxy = null
-  }
-}

package/src/vue/state/index.ts

@@ -1,3 +0,0 @@
-import { State } from './State'
-
-export { State }

package/tests/service/bulkRequests/BulkRequestSender.test.ts

@@ -1,76 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { BulkRequestSender, BulkRequestExecutionMode } from '../../../src/bulkRequests/BulkRequestSender'
-import { BulkRequestWrapper } from '../../../src/bulkRequests/BulkRequestWrapper'
-import { BulkRequestEventEnum } from '../../../src/bulkRequests/BulkRequestEvent.enum'
-
-const createRequest = (options: { failTimes?: number } = {}) => {
-  let calls = 0
-
-  return {
-    send: vi.fn().mockImplementation(() => {
-      calls += 1
-      if (options.failTimes && calls <= options.failTimes) {
-        return Promise.reject(new Error('fail'))
-      }
-      return Promise.resolve('ok')
-    }),
-    isLoading: vi.fn().mockReturnValue(false),
-    setAbortSignal: vi.fn(),
-  }
-}
-
-describe('BulkRequestSender', () => {
-  it('sends requests in parallel and emits success events', async () => {
-    const wrappers = [new BulkRequestWrapper(createRequest() as any), new BulkRequestWrapper(createRequest() as any)]
-
-    const sender = new BulkRequestSender(wrappers, BulkRequestExecutionMode.PARALLEL)
-    const onSuccess = vi.fn()
-
-    sender.on(BulkRequestEventEnum.REQUEST_SUCCESSFUL, onSuccess)
-
-    const result = await sender.send()
-
-    expect(onSuccess).toHaveBeenCalledTimes(2)
-    expect(result.getSuccessCount()).toBe(2)
-    expect(result.getErrorCount()).toBe(0)
-    expect(result.getSuccessfulResponses()).toEqual(['ok', 'ok'])
-  })
-
-  it('retries failed requests and emits failure events when still failing', async () => {
-    const failingRequest = createRequest({ failTimes: 2 })
-    const wrapper = new BulkRequestWrapper(failingRequest as any)
-
-    const sender = new BulkRequestSender([wrapper], BulkRequestExecutionMode.SEQUENTIAL, 1)
-    const onFailed = vi.fn()
-
-    sender.on(BulkRequestEventEnum.REQUEST_FAILED, onFailed)
-
-    await sender.send()
-
-    expect(failingRequest.send).toHaveBeenCalledTimes(2)
-    expect(onFailed).toHaveBeenCalledTimes(1)
-  })
-
-  it('reports loading state when any request is loading', () => {
-    const request1 = createRequest()
-    const request2 = createRequest()
-    request2.isLoading = vi.fn().mockReturnValue(true)
-
-    const sender = new BulkRequestSender(
-      [new BulkRequestWrapper(request1 as any), new BulkRequestWrapper(request2 as any)],
-      BulkRequestExecutionMode.PARALLEL
-    )
-
-    expect(sender.isLoading).toBe(true)
-  })
-
-  it('removes event handlers with off()', () => {
-    const sender = new BulkRequestSender([], BulkRequestExecutionMode.PARALLEL)
-    const handler = vi.fn()
-
-    sender.on(BulkRequestEventEnum.REQUEST_SUCCESSFUL, handler)
-    sender.off(BulkRequestEventEnum.REQUEST_SUCCESSFUL)
-
-    expect((sender as any).events.has(BulkRequestEventEnum.REQUEST_SUCCESSFUL)).toBe(false)
-  })
-})