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

package/src/vue/forms/PropertyAwareArray.ts

@@ -1,81 +0,0 @@
-import { type WritableComputedRef } from 'vue'
-
-/**
- * Repräsentiert eine reaktive Property mit model.value Zugriff
- */
-export interface PropertyAwareField<T> {
-  model: WritableComputedRef<T>
-  errors: string[]
-  dirty: boolean
-}
-
-/**
- * Wandelt ein reguläres Interface in ein property-aware Interface um
- * Jedes Feld vom Typ T wird zu einem PropertyAwareField<T>
- */
-export type PropertyAware<T> = {
-  [K in keyof T]: PropertyAwareField<T[K]>
-}
-/**
- * Extends Array with property awareness.
- * When a form field is defined as an instance of PropertyAwareArray,
- * the BaseForm will transform each element into reactive properties with
- * computed getters/setters, error tracking, and dirty flags.
- */
-export class PropertyAwareArray<T = unknown> extends Array<T> {
-  // Private brand to prevent plain arrays from being assignable to PropertyAwareArray.
-  // This keeps conditional types from treating normal arrays as property-aware.
-  private readonly __propertyAwareArrayBrand!: void
-  /**
-   * Creates a new PropertyAwareArray instance
-   */
-  public constructor(items: T[] = []) {
-    // Call Array constructor with array length
-    super()
-    void this.__propertyAwareArrayBrand
-
-    // Add items to the array
-    if (items && items.length) {
-      items.forEach((item) => this.push(item))
-    }
-  }
-
-  /**
-   * Create a PropertyAwareArray from an existing array
-   */
-  public static override from<T>(arrayLike: ArrayLike<T>): PropertyAwareArray<T> {
-    return new PropertyAwareArray(Array.from(arrayLike))
-  }
-
-  /**
-   * Maps each element using the provided function
-   * Overridden to ensure the return type is PropertyAwareArray<U> rather than Array<U>
-   */
-  public override map<U>(callbackfn: (value: T, index: number, array: T[]) => U): PropertyAwareArray<U> {
-    return new PropertyAwareArray(super.map(callbackfn))
-  }
-
-  /**
-   * Filters elements using the provided function
-   * Overridden to ensure the return type is PropertyAwareArray<T> rather than Array<T>
-   */
-  public override filter(predicate: (value: T, index: number, array: T[]) => boolean): PropertyAwareArray<T> {
-    return new PropertyAwareArray(super.filter(predicate))
-  }
-
-  /**
-   * Returns a shallow copy of the array
-   * Overridden to ensure the return type is PropertyAwareArray<T> rather than Array<T>
-   */
-  public override slice(start?: number, end?: number): PropertyAwareArray<T> {
-    return new PropertyAwareArray(super.slice(start, end))
-  }
-
-  /**
-   * Combines two or more arrays
-   * Overridden to ensure the return type is PropertyAwareArray<T> rather than Array<T>
-   */
-  public override concat(...items: (T | ConcatArray<T>)[]): PropertyAwareArray<T> {
-    return new PropertyAwareArray(super.concat(...items))
-  }
-}

package/src/vue/forms/types/PersistedForm.ts

@@ -1,6 +0,0 @@
-export interface PersistedForm<FormBody> {
-  state: FormBody
-  original: FormBody
-  dirty: Record<keyof FormBody, boolean>
-  touched: Record<keyof FormBody, boolean>
-}

package/src/vue/forms/validation/ValidationMode.enum.ts

@@ -1,14 +0,0 @@
-export enum ValidationMode {
-  // Individual flags
-  NEVER = 0,
-  INSTANTLY = 1, // Validate as soon as form is initialized
-  ON_TOUCH = 2, // Validate when field is touched (focused/blurred)
-  ON_DIRTY = 4, // Validate when field value changes
-  ON_SUBMIT = 8, // Validate on form submit
-  ON_DEPENDENT_CHANGE = 16, // Validate when a field it depends on changes
-
-  // Common combinations
-  DEFAULT = ON_TOUCH | ON_DIRTY | ON_SUBMIT, // Validate when dirty or on submit
-  AGGRESSIVE = INSTANTLY | ON_TOUCH | ON_DIRTY | ON_SUBMIT, // Validate in all situations
-  PASSIVE = ON_SUBMIT // Only validate on submit
-}

package/src/vue/forms/validation/index.ts

@@ -1,15 +0,0 @@
-import { BaseRule } from './rules/BaseRule'
-import { ConfirmedRule } from './rules/ConfirmedRule'
-import { EmailRule } from './rules/EmailRule'
-import { JsonRule } from './rules/JsonRule'
-import { RequiredRule } from './rules/RequiredRule'
-import { UrlRule } from './rules/UrlRule'
-import { MinRule } from './rules/MinRule'
-import { ValidationMode } from './ValidationMode.enum'
-
-import { type BidirectionalRule } from './types/BidirectionalRule'
-import { type ValidationRules } from './types/ValidationRules'
-
-export { BaseRule, ConfirmedRule, EmailRule, JsonRule, RequiredRule, UrlRule, MinRule, ValidationMode }
-
-export type { BidirectionalRule, ValidationRules }

package/src/vue/forms/validation/rules/BaseRule.ts

@@ -1,7 +0,0 @@
-export abstract class BaseRule<FormBody extends object> {
-  public dependsOn: Array<keyof FormBody> = []
-
-  public abstract validate(value: unknown, state: FormBody): boolean
-
-  public abstract getMessage(): string
-}

package/src/vue/forms/validation/rules/ConfirmedRule.ts

@@ -1,39 +0,0 @@
-import { BaseRule } from './BaseRule'
-import { type BidirectionalRule } from '../types/BidirectionalRule'
-
-export class ConfirmedRule<FormBody extends object> extends BaseRule<FormBody> implements BidirectionalRule<FormBody> {
-  protected message: string
-
-  public constructor(
-    protected confirmationField: keyof FormBody,
-    message?: string
-  ) {
-    super()
-
-    this.message = message || `Must match ${String(confirmationField)}`
-
-    // Add the confirmation field as a dependency
-    this.dependsOn = [confirmationField]
-  }
-
-  public validate(value: unknown, formState: FormBody): boolean {
-    // Only validate if both fields have values
-    const confirmationValue = formState[this.confirmationField]
-
-    // If either field is empty, don't show an error yet
-    if (!value || !confirmationValue) {
-      return true
-    }
-
-    return value === confirmationValue
-  }
-
-  public getMessage(): string {
-    return this.message
-  }
-
-  // Implement BidirectionalRule interface
-  public getBidirectionalFields(): Array<keyof FormBody> {
-    return [this.confirmationField]
-  }
-}

package/src/vue/forms/validation/rules/EmailRule.ts

@@ -1,23 +0,0 @@
-import { BaseRule } from './BaseRule'
-
-export class EmailRule<FormBody extends object> extends BaseRule<FormBody> {
-  public constructor(protected message: string = 'Please enter a valid email address') {
-    super()
-  }
-
-  public validate(value: unknown): boolean {
-    if (value === null || value === undefined || value === '') {
-      return true
-    }
-
-    if (typeof value !== 'string') {
-      return false
-    }
-
-    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)
-  }
-
-  public getMessage(): string {
-    return this.message
-  }
-}

package/src/vue/forms/validation/rules/JsonRule.ts

@@ -1,28 +0,0 @@
-import { BaseRule } from './BaseRule'
-
-export class JsonRule<FormBody extends object> extends BaseRule<FormBody> {
-  public constructor(protected message: string = 'Please enter valid JSON') {
-    super()
-  }
-
-  public validate(value: unknown): boolean {
-    if (value === null || value === undefined || value === '') {
-      return true
-    }
-
-    if (typeof value !== 'string') {
-      return false
-    }
-
-    try {
-      JSON.parse(value)
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  public getMessage(): string {
-    return this.message
-  }
-}

package/src/vue/forms/validation/rules/MinRule.ts

@@ -1,61 +0,0 @@
-import { BaseRule } from './BaseRule'
-
-export class MinRule<FormBody extends object> extends BaseRule<FormBody> {
-  /**
-   * Creates a new MinRule
-   * @param min The minimum value (length for strings, value for numbers, length for arrays)
-   * @param message The error message to display if validation fails
-   */
-  public constructor(
-    protected min: number,
-    protected message?: string
-  ) {
-    super()
-  }
-
-  /**
-   * Validates that the value meets the minimum requirement
-   * - For strings: checks if length is at least the specified minimum
-   * - For numbers: checks if value is at least the specified minimum
-   * - For arrays: checks if length is at least the specified minimum
-   * - For other types: always returns false
-   *
-   * @param value The value to validate
-   * @returns boolean indicating if validation passed
-   */
-  public validate(value: unknown): boolean {
-    // Null or undefined values should be handled by RequiredRule, not this rule
-    if (value === null || value === undefined) {
-      return true
-    }
-
-    // For strings, check the length
-    if (typeof value === 'string') {
-      return value.length >= this.min
-    }
-
-    // For numbers, check the value
-    if (typeof value === 'number') {
-      return value >= this.min
-    }
-
-    // For arrays, check the length
-    if (Array.isArray(value)) {
-      return value.length >= this.min
-    }
-
-    // For other types, validation fails
-    return false
-  }
-
-  /**
-   * Returns the error message for the validation
-   */
-  public getMessage(): string {
-    if (this.message) {
-      return this.message
-    }
-
-    return `This field must be at least ${this.min}`
-  }
-}

package/src/vue/forms/validation/rules/RequiredRule.ts

@@ -1,19 +0,0 @@
-import { BaseRule } from './BaseRule'
-
-export class RequiredRule<FormBody extends object> extends BaseRule<FormBody> {
-  public constructor(protected message: string = 'This field is required') {
-    super()
-  }
-
-  public validate(value: keyof FormBody): boolean {
-    if (value === null || value === undefined || value === '') {
-      return false
-    }
-
-    return true
-  }
-
-  public getMessage(): string {
-    return this.message
-  }
-}

package/src/vue/forms/validation/rules/UrlRule.ts

@@ -1,24 +0,0 @@
-import { BaseRule } from './BaseRule'
-
-export class UrlRule<FormBody extends object> extends BaseRule<FormBody> {
-  public constructor(protected message: string = 'Please enter a valid URL') {
-    super()
-  }
-
-  public validate(value: unknown): boolean {
-    if (!value || typeof value !== 'string') {
-      return false
-    }
-
-    try {
-      new URL(value)
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  public getMessage(): string {
-    return this.message
-  }
-}

package/src/vue/forms/validation/types/ValidationRules.ts

@@ -1,15 +0,0 @@
-import { type BaseRule } from '../rules/BaseRule'
-import { type BidirectionalRule } from './BidirectionalRule'
-import { type ValidationMode } from '../ValidationMode.enum'
-
-type Rule<FormBody extends object> = BaseRule<FormBody> & Partial<BidirectionalRule<FormBody>>
-
-export type ValidationRules<FormBody extends object> = Partial<
-  Record<
-    keyof FormBody,
-    {
-      rules: Rule<FormBody>[]
-      options?: { mode?: ValidationMode }
-    }
-  >
->

package/src/vue/index.ts

@@ -1,14 +0,0 @@
-import useIsOpen from './composables/useIsOpen'
-import useModelWrapper from './composables/useModelWrapper'
-import useOnOpen from './composables/useOnOpen'
-import useIsOpenFromVar from './composables/useIsOpenFromVar'
-import useGlobalCheckbox from './composables/useGlobalCheckbox'
-import useIsEmpty from './composables/useIsEmpty'
-import useConfirmDialog from './composables/useConfirmDialog'
-
-import { ConfirmDialogSeverity, type ConfirmDialogOptions } from './composables/useConfirmDialog'
-
-export { useIsOpen, useModelWrapper, useOnOpen, useIsOpenFromVar, useGlobalCheckbox, useIsEmpty, useConfirmDialog }
-
-export { ConfirmDialogSeverity }
-export type { ConfirmDialogOptions }

package/src/vue/requests/factories/VueRequestLoaderFactory.ts

@@ -1,10 +0,0 @@
-import { VueRequestLoader } from '../loaders/VueRequestLoader'
-import { type RequestLoaderContract } from '../../../requests/contracts/RequestLoaderContract'
-import { type Ref } from 'vue'
-import type { RequestLoaderFactoryContract } from '../../../requests'
-
-export class VueRequestLoaderFactory implements RequestLoaderFactoryContract<Ref<boolean>> {
-  public make(): RequestLoaderContract<Ref<boolean>> {
-    return new VueRequestLoader()
-  }
-}

package/src/vue/requests/loaders/VueRequestBatchLoader.ts

@@ -1,35 +0,0 @@
-import { type Ref, ref, computed } from 'vue'
-import { type RequestLoaderContract } from '../../../requests/contracts/RequestLoaderContract'
-
-export class VueRequestBatchLoader implements RequestLoaderContract<Ref<boolean>> {
-  private inFlight: Ref<number> = ref(0)
-  private completed: Ref<number> = ref(0)
-  private expected: number = 0
-
-  constructor(expectedRequests: number = 0) {
-    this.expected = expectedRequests
-  }
-
-  public startBatch(count: number) {
-    this.expected = count
-    this.completed.value = 0
-  }
-
-  public abortBatch() {
-    this.expected = 0
-    this.completed.value = 0
-  }
-
-  public isLoading(): Ref<boolean> {
-    return computed(() => this.inFlight.value > 0 || (this.expected > 0 && this.completed.value < this.expected))
-  }
-
-  public setLoading(loading: boolean): void {
-    if (loading) {
-      this.inFlight.value++
-    } else {
-      this.inFlight.value = Math.max(0, this.inFlight.value - 1)
-      this.completed.value++
-    }
-  }
-}

package/src/vue/requests/loaders/VueRequestLoader.ts

@@ -1,18 +0,0 @@
-import { type Ref, ref } from 'vue'
-import { type RequestLoaderContract } from '../../../requests/contracts/RequestLoaderContract'
-
-export class VueRequestLoader implements RequestLoaderContract<Ref<boolean>> {
-  protected loading: Ref<boolean>
-
-  public constructor(initialLoading: boolean = false) {
-    this.loading = ref<boolean>(initialLoading)
-  }
-
-  isLoading(): Ref<boolean> {
-    return this.loading
-  }
-
-  setLoading(value: boolean): void {
-    this.loading.value = value
-  }
-}

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

@@ -1,145 +0,0 @@
-import { computed, defineComponent, h, type Component as VueComponent, type VNode } from 'vue'
-import { RouterView, useRoute, type RouteLocationNormalizedLoaded } from 'vue-router'
-
-type InjectionState = Record<string, { loading: boolean; error: Error | null }>
-
-/**
- * Drop-in replacement for `<router-view>` that handles route resource
- * injection loading and error states.
- *
- * When any injected resource is loading → renders the route's `loadingComponent`.
- * When any injected resource has an error → renders the route's `errorComponent`
- *   (receives `error` and `refresh` as props).
- * Otherwise → passes `{ Component, route }` to the default scoped slot,
- *   just like `<RouterView>`.
- *
- * Error and loading components are defined in the route via `defineRoute`:
- *
- * ```ts
- * defineRoute<{ credential: CredentialResource }>()({
- *   path: '/credentials/:credentialId',
- *   component: CredentialShowPage,
- *   errorComponent: GenericErrorPage,
- *   loadingComponent: LoadingSpinner,
- *   inject: {
- *     credential: {
- *       from: 'credentialId',
- *       resolve: (id) => new RouteResourceRequestResolver(new CredentialShowRequest(id)),
- *     },
- *   },
- * })
- * ```
- *
- * Set `lazy: false` to render the target component immediately (without
- * waiting for resources). The component can then handle loading/error
- * states itself via `useRouteResource()`:
- *
- * ```ts
- * defineRoute<{ credential: CredentialResource }>()({
- *   path: '/credentials/:credentialId',
- *   component: CredentialShowPage,
- *   lazy: false,
- *   inject: { ... },
- * })
- * ```
- *
- * Usage in layout (supports the same v-slot pattern as RouterView):
- * ```vue
- * <RouteResourceBoundView v-slot="{ Component, route }">
- *   <component :is="Component" v-if="Component" :key="route.meta.usePathKey ? route.path : undefined" />
- *   <EmptyState v-else />
- * </RouteResourceBoundView>
- * ```
- *
- * Or without a slot (renders the matched component automatically):
- * ```vue
- * <RouteResourceBoundView />
- * ```
- */
-export const RouteResourceBoundView = defineComponent({
-  name: 'RouteResourceBoundView',
-
-  setup(_, { slots }) {
-    const route = useRoute()
-
-    const injectionState = computed(() => {
-      return route.meta._injectionState as InjectionState | undefined
-    })
-
-    const firstError = computed((): Error | null => {
-      const state = injectionState.value
-      if (!state) return null
-
-      for (const key of Object.keys(state)) {
-        const entry = state[key]
-        if (entry?.error) return entry.error
-      }
-
-      return null
-    })
-
-    const anyLoading = computed((): boolean => {
-      const state = injectionState.value
-      if (!state) return false
-
-      return Object.keys(state).some((key) => state[key]?.loading)
-    })
-
-    const refresh = async () => {
-      const state = injectionState.value
-      if (!state) return
-
-      const erroredProps = Object.keys(state).filter((key) => state[key]?.error)
-
-      await Promise.all(erroredProps.map((propName) => route.meta.refresh?.(propName)))
-    }
-
-    /**
-     * Core render logic that decides which slot/component to show
-     * given the resolved Component and route from RouterView.
-     */
-    function renderContent(Component: VueComponent | undefined, resolvedRoute: RouteLocationNormalizedLoaded): VNode | VNode[] | undefined {
-      const isLazy = resolvedRoute.meta._lazy !== false
-
-      if (isLazy) {
-        if (firstError.value) {
-          const errorComponent = resolvedRoute.meta._errorComponent
-
-          if (errorComponent) {
-            return h(errorComponent, { error: firstError.value, refresh })
-          }
-
-          return slots['error']?.({ error: firstError.value, refresh })
-        }
-
-        if (anyLoading.value) {
-          const loadingComponent = resolvedRoute.meta._loadingComponent
-
-          if (loadingComponent) {
-            return h(loadingComponent)
-          }
-
-          return slots['loading']?.()
-        }
-      }
-
-      if (slots['default']) {
-        return slots['default']({ Component, route: resolvedRoute })
-      }
-
-      if (Component) {
-        return h(Component)
-      }
-
-      return undefined
-    }
-
-    return () => {
-      return h(RouterView, null, {
-        default: ({ Component, route: resolvedRoute }: { Component: VueComponent | undefined; route: RouteLocationNormalizedLoaded }) => {
-          return renderContent(Component, resolvedRoute)
-        }
-      })
-    }
-  }
-})

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

@@ -1,11 +0,0 @@
-import { type DataRequest, type Resolver } from './types'
-
-export class RouteResourceRequestResolver<T> implements Resolver<T> {
-  public constructor(private request: DataRequest<T>) {}
-
-  public async resolve(): Promise<T> {
-    const response = await this.request.send()
-
-    return response.getData()
-  }
-}

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

@@ -1,59 +0,0 @@
-import { markRaw, type Component } from 'vue'
-import { type RouteRecordRaw } from 'vue-router'
-import { type InjectConfig } from './types'
-
-/**
- * Type-safe route definition helper that ties:
- * - component props type (Props)
- * - inject config types (must resolve Props[K])
- *
- * Usage:
- * export default defineRoute<{ product: ProductResource }>()({
- *   path: '/products/:productId',
- *   component: ProductShowPage,
- *   errorComponent: GenericErrorPage,
- *   loadingComponent: LoadingSpinner,
- *   inject: { product: { from: 'productId', resolve: ... } },
- * })
- */
-export function defineRoute<Props extends Record<string, unknown>>() {
-  return function <
-    T extends RouteRecordRaw & {
-      inject?: InjectConfig<Props>
-      errorComponent?: Component
-      loadingComponent?: Component
-      lazy?: boolean
-    }
-  >(route: T): RouteRecordRaw {
-    const originalProps = route.props
-
-    if (route.errorComponent) {
-      route.meta = route.meta ?? {}
-      route.meta._errorComponent = markRaw(route.errorComponent)
-      delete route.errorComponent
-    }
-
-    if (route.loadingComponent) {
-      route.meta = route.meta ?? {}
-      route.meta._loadingComponent = markRaw(route.loadingComponent)
-      delete route.loadingComponent
-    }
-
-    if (route.lazy !== undefined) {
-      route.meta = route.meta ?? {}
-      route.meta._lazy = route.lazy
-      delete route.lazy
-    }
-
-    route.props = (to) => {
-      const baseProps = typeof originalProps === 'function' ? originalProps(to) : originalProps === true ? to.params : (originalProps ?? {})
-
-      return {
-        ...(baseProps as Record<string, unknown>),
-        ...((to.meta._injectedProps as Record<string, unknown>) ?? {})
-      }
-    }
-
-    return route
-  }
-}

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

@@ -1,11 +0,0 @@
-import { defineRoute } from './defineRoute'
-import { installRouteInjection } from './installRouteInjection'
-import { RouteResourceBoundView } from './RouteResourceBoundView'
-import { RouteResourceRequestResolver } from './RouteResourceRequestResolver'
-import { useRouteResource } from './useRouteResource'
-
-import type { DataRequest, InjectConfig, Resolver } from './types'
-
-export { defineRoute, installRouteInjection, RouteResourceBoundView, RouteResourceRequestResolver, useRouteResource }
-
-export type { DataRequest, InjectConfig, Resolver }