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

package/docs/vue/requests/loading.md

@@ -1,51 +0,0 @@
-# Loading
-
-For Vue apps, the library includes `VueRequestLoader`, `VueRequestLoaderFactory`, and `VueRequestBatchLoader`, which
-use Vue refs to track loading state.
-
-## Registering the Vue Loader Factory
-
-```typescript
-import { BaseRequest } from '@blueprint-ts/core/requests'
-import { VueRequestLoaderFactory } from '@blueprint-ts/core/vue/requests'
-
-BaseRequest.setRequestLoaderFactory(new VueRequestLoaderFactory())
-```
-
-## Reading Loading State
-
-```typescript
-const request = new ExpenseIndexRequest()
-
-request.send()
-
-const isLoading = request.isLoading()
-// isLoading is a Ref<boolean> when using VueRequestLoaderFactory
-```
-
-## Batch Loading
-
-`VueRequestBatchLoader` can track the loading state of multiple requests. Use it when you want a single loading ref to
-reflect a batch of requests.
-
-```typescript
-import { VueRequestBatchLoader } from '@blueprint-ts/core/vue/requests'
-
-const batchLoader = new VueRequestBatchLoader(2)
-batchLoader.startBatch(2)
-
-const requestA = new ExpenseIndexRequest().setRequestLoader(batchLoader)
-const requestB = new ExpenseIndexRequest().setRequestLoader(batchLoader)
-
-requestA.send()
-requestB.send()
-
-const isLoading = batchLoader.isLoading()
-```
-
-If the batch will not complete (for example, when a chained request fails), call `abortBatch()` to stop waiting for the
-remaining requests:
-
-```typescript
-batchLoader.abortBatch()
-```

package/docs/vue/router/route-resource-binding.md

@@ -1,240 +0,0 @@
-# Route Resource Binding
-
-When using `vue-router`, you can automatically bind route parameters to resources, similar to how Laravel's route model binding works.
-
-## Setup
-
-To enable the router to load resources automatically, install the route injection plugin when initializing your router:
-
-```ts
-import { installRouteInjection } from '@blueprint-ts/core/vue/router/routeResourceBinding'
-
-installRouteInjection(router)
-```
-
-## Defining Routes
-
-Use the `defineRoute` helper to define your routes and specify which parameters should be resolved into resources:
-
-```ts
-import { defineRoute, RouteResourceRequestResolver } from '@blueprint-ts/core/vue/router/routeResourceBinding'
-import ProductDetailPage from '@/pages/ProductDetailPage.vue'
-
-export default defineRoute<{
-    product: ProductResource
-}>()({
-    path: ':productId',
-    name: 'products.show',
-    component: ProductDetailPage,
-    meta: {
-        inject: {
-            product: {
-                from: 'productId',
-                resolve: (productId: string) => {
-                    return new RouteResourceRequestResolver(
-                            new ProductShowRequest(productId)
-                    )
-                }
-            }
-        }
-    }
-})
-```
-
-Navigation is blocking by default. Cached values are reused when navigating between child routes with unchanged parameters.
-
-## Usage in Components
-
-Your component can directly access the resolved resource via props:
-
-```vue
-<script setup lang="ts">
-const props = defineProps<{
-    product: ProductResource
-}>()
-</script>
-```
-
-## Handling Loading & Error States
-
-### Using `RouteResourceBoundView`
-
-`RouteResourceBoundView` is a drop-in replacement for `<RouterView>` that automatically handles loading and error states. Define error and loading components directly in the route:
-
-```ts
-import { defineRoute, RouteResourceRequestResolver } from '@blueprint-ts/core/vue/router/routeResourceBinding'
-import ProductDetailPage from '@/pages/ProductDetailPage.vue'
-import GenericErrorPage from '@/pages/GenericErrorPage.vue'
-import LoadingSpinner from '@/components/LoadingSpinner.vue'
-
-export default defineRoute<{
-    product: ProductResource
-}>()({
-    path: ':productId',
-    name: 'products.show',
-    component: ProductDetailPage,
-    errorComponent: GenericErrorPage,
-    loadingComponent: LoadingSpinner,
-    meta: {
-        inject: {
-            product: {
-                from: 'productId',
-                resolve: (productId: string) => {
-                    return new RouteResourceRequestResolver(
-                            new ProductShowRequest(productId)
-                    )
-                }
-            }
-        }
-    }
-})
-```
-
-Then replace `<RouterView>` with `<RouteResourceBoundView>` in your layout:
-
-```vue
-<template>
-  <RouteResourceBoundView />
-</template>
-
-<script setup lang="ts">
-import { RouteResourceBoundView } from '@blueprint-ts/core/vue/router/routeResourceBinding'
-</script>
-```
-
-The `errorComponent` receives `error` and `refresh` as props. The `refresh` function retries all failed resources:
-
-```vue
-<!-- GenericErrorPage.vue -->
-<template>
-  <div>
-    <p>{{ error.message }}</p>
-    <button @click="refresh">Try Again</button>
-  </div>
-</template>
-
-<script setup lang="ts">
-defineProps<{
-    error: Error
-    refresh: () => Promise<void>
-}>()
-</script>
-```
-
-#### Using Scoped Slots
-
-`RouteResourceBoundView` supports the same `v-slot` pattern as `<RouterView>`:
-
-```vue
-<RouteResourceBoundView v-slot="{ Component, route }">
-  <component
-    :is="Component"
-    v-if="Component"
-  />
-  <EmptyState v-else />
-</RouteResourceBoundView>
-```
-
-When no `errorComponent` or `loadingComponent` is defined on the route, you can use named slots as fallbacks:
-
-```vue
-<RouteResourceBoundView>
-  <template #default="{ Component, route }">
-    <component :is="Component" v-if="Component" />
-  </template>
-
-  <template #loading>
-    <LoadingSpinner />
-  </template>
-
-  <template #error="{ error, refresh }">
-    <div>
-      <p>{{ error.message }}</p>
-      <button @click="refresh">Retry</button>
-    </div>
-  </template>
-</RouteResourceBoundView>
-```
-
-### Using `useRouteResource` (Manual Handling)
-
-If you prefer to handle loading and error states inside the component itself, set `lazy: false` on the route. This renders the component immediately while resources resolve in the background:
-
-```ts
-export default defineRoute<{
-    product: ProductResource
-}>()({
-    path: ':productId',
-    name: 'products.show',
-    component: ProductDetailPage,
-    lazy: false,
-    meta: {
-        inject: {
-            product: {
-                from: 'productId',
-                resolve: (productId: string) => {
-                    return new RouteResourceRequestResolver(
-                            new ProductShowRequest(productId)
-                    )
-                }
-            }
-        }
-    }
-})
-```
-
-Then use the `useRouteResource` composable inside your component:
-
-```vue
-<template>
-  <div v-if="isLoading">Loading...</div>
-  <div v-else-if="error">
-    <p>{{ error.message }}</p>
-    <button @click="refresh">Retry</button>
-  </div>
-  <div v-else>
-    <h1>{{ product.name }}</h1>
-  </div>
-</template>
-
-<script setup lang="ts">
-import { useRouteResource } from '@blueprint-ts/core/vue/router/routeResourceBinding'
-
-const props = defineProps<{
-    product: ProductResource
-}>()
-
-const { refresh, isLoading, error } = useRouteResource('product')
-</script>
-```
-
-`useRouteResource` returns:
-
-| Property    | Type                      | Description                              |
-|-------------|---------------------------|------------------------------------------|
-| `isLoading` | `ComputedRef<boolean>`    | `true` while the resource is resolving   |
-| `error`     | `ComputedRef<Error\|null>` | The error if resolution failed, else `null` |
-| `refresh`   | `(options?: { silent?: boolean }) => Promise<void>` | Re-fetches the resource. Pass `{ silent: true }` to suppress the loading state. |
-
-#### Silent Refresh
-
-By default, calling `refresh()` sets `isLoading` to `true` while the resource is being re-fetched, which causes `RouteResourceBoundView` to show the loading component. If you want to refresh the resource in the background without triggering the loading state (e.g. polling or optimistic updates), pass `{ silent: true }`:
-
-```ts
-const { refresh } = useRouteResource('product')
-
-// Normal refresh — triggers loading state
-await refresh()
-
-// Silent refresh — does not trigger loading state
-await refresh({ silent: true })
-```
-
-A silent refresh still updates the `error` state if the request fails.
-
-### Lazy vs Non-Lazy
-
-| Option          | Behavior                                                                                      |
-|-----------------|-----------------------------------------------------------------------------------------------|
-| `lazy: true` (default) | `RouteResourceBoundView` intercepts loading/error states and shows the appropriate component |
-| `lazy: false`   | The target component renders immediately; use `useRouteResource()` for manual state handling  |

package/docs/vue/state.md

@@ -1,309 +0,0 @@
-# State Management
-
-## Overview
-The `State` class provides a reactive, type-safe state management system with rich features like change detection, nested property watching, persistence, and more. It's designed to make state management in Vue applications clean and flexible.
-
-## Core Features
-- **Type-safe state**: Fully typed with TypeScript generics
-- **Reactive properties**: Seamless integration with Vue's reactivity system
-- **Nested property watching**: Track changes to deeply nested properties
-- **Persistence options**: Optional state persistence between sessions
-- **Change subscriptions**: React to state changes with optional debouncing
-- **Deep object watching**: Special handling for nested objects
-- **Efficient equality checking**: Smart comparison of state values
-- **State export/import**: Easily serialize and deserialize state
-- **Reset capability**: Revert to initial state when needed
-
-## Usage Guide
-### Creating a State Class
-Create a new state by extending the base class and defining your interface:
-
-```typescript
-import { State } from '@blueprint-ts/core/vue/state'
-import { type PersistenceDriver, LocalStorageDriver } from '@blueprint-ts/core/persistenceDrivers'
-
-// Define your state interface
-interface UserStateInterface {
-  name: string;
-  email: string;
-  preferences: {
-    darkMode: boolean;
-    notifications: boolean;
-  };
-}
-
-// Create your state class
-class UserState extends State<UserStateInterface> {
-  constructor() {
-    super(
-      {
-        name: '',
-        email: '',
-        preferences: {
-          darkMode: false,
-          notifications: true
-        }
-      }, 
-      {
-        persist: true, // Enable persistence
-        persistSuffix: 'user' // Optional namespace for the storage key
-      }
-    );
-  }
-  
-  // Optional: Override persistence method
-  protected override getPersistenceDriver(): PersistenceDriver {
-    return new LocalStorageDriver()
-  }
-}
-
-// Create an instance
-export const userState = new UserState();
-```
-
-### Accessing State
-
-````typescript
-// Read
-const userName = userState.state.name;
-
-// Write
-userState.state.name = 'John Doe';
-````
-
-### Subscribing to Changes
-Listen for changes to specific properties using the method: `subscribe`
-
-#### Basic subscription to a single property
-````typescript
-// Subscribe to changes on a top-level property
-userState.subscribe(
-  'name',
-  (newValue, oldValue) => {
-    console.log(`Name changed from ${oldValue} to ${newValue}`);
-  }
-);
-````
-
-`subscribe` returns an unsubscribe function:
-
-````typescript
-const unsubscribe = userState.subscribe('name', () => {
-  // ...
-});
-
-unsubscribe();
-````
-
-#### Subscribing to nested properties
-
-````typescript
-// Subscribe to a nested property using dot notation
-userState.subscribe(
-  'preferences.darkMode',
-  (newValue, oldValue) => {
-    console.log(`Dark mode changed from ${oldValue} to ${newValue}`);
-    // Update UI theme
-  }
-);
-````
-
-#### Debounced subscriptions
-
-````typescript
-// Debounce the handler to avoid frequent updates
-userState.subscribe(
-  'email',
-  (newValue, oldValue) => {
-    // This will only execute after 300ms of stability
-    validateEmail(newValue);
-  },
-  { debounce: 300 }
-);
-````
-
-#### Watching multiple properties
-````typescript
-// Subscribe to multiple properties at once
-userState.subscribe(
-  ['name', 'email'],
-  (changedPath, state) => {
-    console.log(`Property ${changedPath} changed`);
-    console.log('Current state:', state);
-  }
-);
-````
-
-### State Persistence
-Enable state persistence by passing `persist: true` in the constructor options. You can optionally set `persistSuffix` to namespace the storage key. Override the method `getPersistenceDriver` to use different storage mechanisms:
-
-````typescript
-// Examples of different persistence drivers:
-protected override getPersistenceDriver(): PersistenceDriver {
-  // Session storage (lasts until browser tab is closed)
-  return new SessionStorageDriver();
-  
-  // Local storage (persists between sessions)
-  // return new LocalStorageDriver();
-  
-  // Non-persistent (for testing or when persistence not needed)
-  // return new NonPersistentDriver();
-}
-````
-
-You can inspect the computed key via `state.persistKey`.
-
-### Importing and Exporting State
-
-Export the current state to a plain object or import values:
-
-````typescript
-// Export current state as a plain object
-const stateSnapshot = userState.export();
-console.log(stateSnapshot);
-
-// Import partial state
-userState.import({
-  name: 'Jane Doe',
-  preferences: {
-    darkMode: true
-  }
-});
-
-````
-
-### Resetting State
-Reset the state to its initial values:
-
-````typescript
-// Reset to initial values
-userState.reset();
-````
-
-````
-userState.subscribe(
-  'name',
-  (newValue, oldValue) => {
-    console.log(`Name reset from ${oldValue} to ${newValue}`);
-  },
-  { executeOnReset: true }
-);
-````
-
-### Cleanup
-If you create short‑lived state instances, call `destroy()` to remove watchers and release references:
-
-````typescript
-userState.destroy();
-````
-
-## Advanced Features
-### Deep Object Watching
-When you modify nested properties, the system automatically detects these changes and triggers appropriate callbacks:
-
-````typescript
-// Both of these will trigger the 'preferences.darkMode' subscription
-userState.state.preferences.darkMode = true;
-userState.state.preferences = { darkMode: true, notifications: false };
-````
-
-### Type-Safe Path Access
-The state system enforces type safety for property paths:
-
-````typescript
-// TypeScript will error on invalid paths
-userState.subscribe(
-  'preferences.invalidProperty', // Type error!
-  (newValue, oldValue) => {
-    // ...
-  }
-);
-````
-
-### Smart Comparison
-The system performs deep equality checks before triggering change handlers, ensuring callbacks are only called when values actually change:
-
-````typescript
-// This won't trigger change handlers if the values are deeply equal
-userState.state.preferences = { darkMode: false, notifications: true };
-````
-
-## Example: Complete Workflow
-
-````typescript
-// 1. Define state interface
-interface FormState {
-  username: string;
-  password: string;
-  validation: {
-    usernameValid: boolean;
-    passwordValid: boolean;
-  };
-}
-
-// 2. Create state class
-class FormStateManager extends State<FormState> {
-  constructor() {
-    super({
-      username: '',
-      password: '',
-      validation: {
-        usernameValid: false,
-        passwordValid: false
-      }
-    });
-  }
-  
-  // Helper methods can be added to state classes
-  public validateForm(): boolean {
-    return this.state.validation.usernameValid && 
-           this.state.validation.passwordValid;
-  }
-}
-
-// 3. Create instance
-const formState = new FormStateManager();
-
-// 4. Set up subscriptions
-formState.subscribe(
-  'username',
-  (username) => {
-    // Validate username
-    const valid = username.length >= 3;
-    formState.state.validation.usernameValid = valid;
-  },
-  { debounce: 300 }
-);
-
-formState.subscribe(
-  'password',
-  (password) => {
-    // Validate password
-    const valid = password.length >= 8;
-    formState.state.validation.passwordValid = valid;
-  },
-  { debounce: 300 }
-);
-
-// 5. Watch form validity
-formState.subscribe(
-  ['validation.usernameValid', 'validation.passwordValid'],
-  (_, state) => {
-    const submitButton = document.getElementById('submit');
-    if (formState.validateForm()) {
-      submitButton.disabled = false;
-    } else {
-      submitButton.disabled = true;
-    }
-  }
-);
-
-// 6. Use the state
-formState.state.username = 'john_doe';
-formState.state.password = 'securePassword123';
-
-// 7. Reset when needed
-document.getElementById('reset').addEventListener('click', () => {
-  formState.reset();
-});
-````

package/env.d.ts

@@ -1 +0,0 @@
-/// <reference types="vite/client" />

package/eslint.config.js

@@ -1,15 +0,0 @@
-import eslint from '@eslint/js';
-import tseslint from 'typescript-eslint';
-import pluginVue from 'eslint-plugin-vue';
-
-import {
-  defineConfigWithVueTs,
-  vueTsConfigs,
-} from '@vue/eslint-config-typescript'
-
-export default defineConfigWithVueTs(
-  eslint.configs.recommended,
-  ...tseslint.configs.recommended,
-  ...pluginVue.configs['flat/recommended'],
-  vueTsConfigs.recommended,
-)

package/release-tool.json

@@ -1,26 +0,0 @@
-{
-  "version_file": "package.json",
-  "version_pattern": "\"version\":\\s*\"([0-9]+\\.[0-9]+\\.[0-9]+(?:-[a-z]+\\.[0-9]+)?)\"",
-  "version_template": "\"version\": \"{}\"",
-  "develop_branch": "develop",
-  "main_branch": "main",
-  "docs": {
-    "build": {
-      "cwd": "./docs",
-      "commands": [
-        ["npm", "ci"],
-        ["npm", "run", "docs:build"]
-      ],
-      "output_dir": ".vitepress/dist"
-    },
-    "publish": {
-      "repo_path": "./docs",
-      "remote": "origin",
-      "branch": "gh-pages",
-      "subdir": "",
-      "commit_message": "docs: publish {tag}",
-      "add_nojekyll": true,
-      "force_push": true
-    }
-  }
-}

package/src/bulkRequests/BulkRequestEvent.enum.ts

@@ -1,4 +0,0 @@
-export enum BulkRequestEventEnum {
-  REQUEST_SUCCESSFUL = 'REQUEST_SUCCESSFUL',
-  REQUEST_FAILED = 'REQUEST_FAILED'
-}