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

package/dist/vue/forms/PropertyAwareArray.d.ts

@@ -0,0 +1,53 @@
+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 declare class PropertyAwareArray<T = unknown> extends Array<T> {
+    private readonly __propertyAwareArrayBrand;
+    /**
+     * Creates a new PropertyAwareArray instance
+     */
+    constructor(items?: T[]);
+    /**
+     * Create a PropertyAwareArray from an existing array
+     */
+    static from<T>(arrayLike: ArrayLike<T>): PropertyAwareArray<T>;
+    /**
+     * Maps each element using the provided function
+     * Overridden to ensure the return type is PropertyAwareArray<U> rather than Array<U>
+     */
+    map<U>(callbackfn: (value: T, index: number, array: T[]) => U): PropertyAwareArray<U>;
+    /**
+     * Filters elements using the provided function
+     * Overridden to ensure the return type is PropertyAwareArray<T> rather than Array<T>
+     */
+    filter(predicate: (value: T, index: number, array: T[]) => boolean): PropertyAwareArray<T>;
+    /**
+     * Returns a shallow copy of the array
+     * Overridden to ensure the return type is PropertyAwareArray<T> rather than Array<T>
+     */
+    slice(start?: number, end?: number): PropertyAwareArray<T>;
+    /**
+     * Combines two or more arrays
+     * Overridden to ensure the return type is PropertyAwareArray<T> rather than Array<T>
+     */
+    concat(...items: (T | ConcatArray<T>)[]): PropertyAwareArray<T>;
+}

package/dist/vue/forms/PropertyAwareArray.js

@@ -0,0 +1,54 @@
+/**
+ * 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 extends Array {
+    /**
+     * Creates a new PropertyAwareArray instance
+     */
+    constructor(items = []) {
+        // 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
+     */
+    static from(arrayLike) {
+        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>
+     */
+    map(callbackfn) {
+        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>
+     */
+    filter(predicate) {
+        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>
+     */
+    slice(start, end) {
+        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>
+     */
+    concat(...items) {
+        return new PropertyAwareArray(super.concat(...items));
+    }
+}

package/{src/vue/forms/index.ts → dist/vue/forms/index.d.ts}

@@ -1,11 +1,9 @@
-import { BaseForm, propertyAwareToRaw } from './BaseForm'
-import { type PersistedForm } from './types/PersistedForm'
-import { LocalStorageDriver } from '../../persistenceDrivers/LocalStorageDriver'
-import { NonPersistentDriver } from '../../persistenceDrivers/NonPersistentDriver'
-import { SessionStorageDriver } from '../../persistenceDrivers/SessionStorageDriver'
-import { type PersistenceDriver } from '../../persistenceDrivers/types/PersistenceDriver'
-import { PropertyAwareArray, type PropertyAwareField, type PropertyAware } from './PropertyAwareArray'
-
-export { BaseForm, propertyAwareToRaw, PropertyAwareArray, NonPersistentDriver, SessionStorageDriver, LocalStorageDriver }
-
-export type { PersistedForm, PersistenceDriver, PropertyAwareField, PropertyAware }
+import { BaseForm, propertyAwareToRaw } from './BaseForm';
+import { type PersistedForm } from './types/PersistedForm';
+import { LocalStorageDriver } from '../../persistenceDrivers/LocalStorageDriver';
+import { NonPersistentDriver } from '../../persistenceDrivers/NonPersistentDriver';
+import { SessionStorageDriver } from '../../persistenceDrivers/SessionStorageDriver';
+import { type PersistenceDriver } from '../../persistenceDrivers/types/PersistenceDriver';
+import { PropertyAwareArray, type PropertyAwareField, type PropertyAware } from './PropertyAwareArray';
+export { BaseForm, propertyAwareToRaw, PropertyAwareArray, NonPersistentDriver, SessionStorageDriver, LocalStorageDriver };
+export type { PersistedForm, PersistenceDriver, PropertyAwareField, PropertyAware };

package/dist/vue/forms/index.js

@@ -0,0 +1,6 @@
+import { BaseForm, propertyAwareToRaw } from './BaseForm';
+import { LocalStorageDriver } from '../../persistenceDrivers/LocalStorageDriver';
+import { NonPersistentDriver } from '../../persistenceDrivers/NonPersistentDriver';
+import { SessionStorageDriver } from '../../persistenceDrivers/SessionStorageDriver';
+import { PropertyAwareArray } from './PropertyAwareArray';
+export { BaseForm, propertyAwareToRaw, PropertyAwareArray, NonPersistentDriver, SessionStorageDriver, LocalStorageDriver };

package/dist/vue/forms/types/PersistedForm.d.ts

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

package/dist/vue/forms/types/PersistedForm.js

@@ -0,0 +1 @@
+export {};

package/dist/vue/forms/validation/ValidationMode.enum.d.ts

@@ -0,0 +1,11 @@
+export declare enum ValidationMode {
+    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
+    DEFAULT = 14,// Validate when dirty or on submit
+    AGGRESSIVE = 15,// Validate in all situations
+    PASSIVE = 8
+}

package/dist/vue/forms/validation/ValidationMode.enum.js

@@ -0,0 +1,14 @@
+export var ValidationMode;
+(function (ValidationMode) {
+    // Individual flags
+    ValidationMode[ValidationMode["NEVER"] = 0] = "NEVER";
+    ValidationMode[ValidationMode["INSTANTLY"] = 1] = "INSTANTLY";
+    ValidationMode[ValidationMode["ON_TOUCH"] = 2] = "ON_TOUCH";
+    ValidationMode[ValidationMode["ON_DIRTY"] = 4] = "ON_DIRTY";
+    ValidationMode[ValidationMode["ON_SUBMIT"] = 8] = "ON_SUBMIT";
+    ValidationMode[ValidationMode["ON_DEPENDENT_CHANGE"] = 16] = "ON_DEPENDENT_CHANGE";
+    // Common combinations
+    ValidationMode[ValidationMode["DEFAULT"] = 14] = "DEFAULT";
+    ValidationMode[ValidationMode["AGGRESSIVE"] = 15] = "AGGRESSIVE";
+    ValidationMode[ValidationMode["PASSIVE"] = 8] = "PASSIVE"; // Only validate on submit
+})(ValidationMode || (ValidationMode = {}));

package/dist/vue/forms/validation/index.d.ts

@@ -0,0 +1,12 @@
+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/dist/vue/forms/validation/index.js

@@ -0,0 +1,9 @@
+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';
+export { BaseRule, ConfirmedRule, EmailRule, JsonRule, RequiredRule, UrlRule, MinRule, ValidationMode };

package/dist/vue/forms/validation/rules/BaseRule.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class BaseRule<FormBody extends object> {
+    dependsOn: Array<keyof FormBody>;
+    abstract validate(value: unknown, state: FormBody): boolean;
+    abstract getMessage(): string;
+}

package/dist/vue/forms/validation/rules/BaseRule.js

@@ -0,0 +1,5 @@
+export class BaseRule {
+    constructor() {
+        this.dependsOn = [];
+    }
+}

package/dist/vue/forms/validation/rules/ConfirmedRule.d.ts

@@ -0,0 +1,10 @@
+import { BaseRule } from './BaseRule';
+import { type BidirectionalRule } from '../types/BidirectionalRule';
+export declare class ConfirmedRule<FormBody extends object> extends BaseRule<FormBody> implements BidirectionalRule<FormBody> {
+    protected confirmationField: keyof FormBody;
+    protected message: string;
+    constructor(confirmationField: keyof FormBody, message?: string);
+    validate(value: unknown, formState: FormBody): boolean;
+    getMessage(): string;
+    getBidirectionalFields(): Array<keyof FormBody>;
+}

package/dist/vue/forms/validation/rules/ConfirmedRule.js

@@ -0,0 +1,26 @@
+import { BaseRule } from './BaseRule';
+export class ConfirmedRule extends BaseRule {
+    constructor(confirmationField, message) {
+        super();
+        this.confirmationField = confirmationField;
+        this.message = message || `Must match ${String(confirmationField)}`;
+        // Add the confirmation field as a dependency
+        this.dependsOn = [confirmationField];
+    }
+    validate(value, formState) {
+        // 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;
+    }
+    getMessage() {
+        return this.message;
+    }
+    // Implement BidirectionalRule interface
+    getBidirectionalFields() {
+        return [this.confirmationField];
+    }
+}

package/dist/vue/forms/validation/rules/EmailRule.d.ts

@@ -0,0 +1,7 @@
+import { BaseRule } from './BaseRule';
+export declare class EmailRule<FormBody extends object> extends BaseRule<FormBody> {
+    protected message: string;
+    constructor(message?: string);
+    validate(value: unknown): boolean;
+    getMessage(): string;
+}

package/dist/vue/forms/validation/rules/EmailRule.js

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

package/dist/vue/forms/validation/rules/JsonRule.d.ts

@@ -0,0 +1,7 @@
+import { BaseRule } from './BaseRule';
+export declare class JsonRule<FormBody extends object> extends BaseRule<FormBody> {
+    protected message: string;
+    constructor(message?: string);
+    validate(value: unknown): boolean;
+    getMessage(): string;
+}

package/dist/vue/forms/validation/rules/JsonRule.js

@@ -0,0 +1,25 @@
+import { BaseRule } from './BaseRule';
+export class JsonRule extends BaseRule {
+    constructor(message = 'Please enter valid JSON') {
+        super();
+        this.message = message;
+    }
+    validate(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        if (typeof value !== 'string') {
+            return false;
+        }
+        try {
+            JSON.parse(value);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    getMessage() {
+        return this.message;
+    }
+}

package/dist/vue/forms/validation/rules/MinRule.d.ts

@@ -0,0 +1,26 @@
+import { BaseRule } from './BaseRule';
+export declare class MinRule<FormBody extends object> extends BaseRule<FormBody> {
+    protected min: number;
+    protected message?: string | undefined;
+    /**
+     * 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
+     */
+    constructor(min: number, message?: string | undefined);
+    /**
+     * 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
+     */
+    validate(value: unknown): boolean;
+    /**
+     * Returns the error message for the validation
+     */
+    getMessage(): string;
+}

package/dist/vue/forms/validation/rules/MinRule.js

@@ -0,0 +1,52 @@
+import { BaseRule } from './BaseRule';
+export class MinRule extends BaseRule {
+    /**
+     * 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
+     */
+    constructor(min, message) {
+        super();
+        this.min = min;
+        this.message = message;
+    }
+    /**
+     * 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
+     */
+    validate(value) {
+        // 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
+     */
+    getMessage() {
+        if (this.message) {
+            return this.message;
+        }
+        return `This field must be at least ${this.min}`;
+    }
+}

package/dist/vue/forms/validation/rules/RequiredRule.d.ts

@@ -0,0 +1,7 @@
+import { BaseRule } from './BaseRule';
+export declare class RequiredRule<FormBody extends object> extends BaseRule<FormBody> {
+    protected message: string;
+    constructor(message?: string);
+    validate(value: keyof FormBody): boolean;
+    getMessage(): string;
+}

package/dist/vue/forms/validation/rules/RequiredRule.js

@@ -0,0 +1,16 @@
+import { BaseRule } from './BaseRule';
+export class RequiredRule extends BaseRule {
+    constructor(message = 'This field is required') {
+        super();
+        this.message = message;
+    }
+    validate(value) {
+        if (value === null || value === undefined || value === '') {
+            return false;
+        }
+        return true;
+    }
+    getMessage() {
+        return this.message;
+    }
+}

package/dist/vue/forms/validation/rules/UrlRule.d.ts

@@ -0,0 +1,7 @@
+import { BaseRule } from './BaseRule';
+export declare class UrlRule<FormBody extends object> extends BaseRule<FormBody> {
+    protected message: string;
+    constructor(message?: string);
+    validate(value: unknown): boolean;
+    getMessage(): string;
+}

package/dist/vue/forms/validation/rules/UrlRule.js

@@ -0,0 +1,22 @@
+import { BaseRule } from './BaseRule';
+export class UrlRule extends BaseRule {
+    constructor(message = 'Please enter a valid URL') {
+        super();
+        this.message = message;
+    }
+    validate(value) {
+        if (!value || typeof value !== 'string') {
+            return false;
+        }
+        try {
+            new URL(value);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    getMessage() {
+        return this.message;
+    }
+}

package/{src/vue/forms/validation/types/BidirectionalRule.ts → dist/vue/forms/validation/types/BidirectionalRule.d.ts}

@@ -4,8 +4,8 @@
  * automatically set up bidirectionally
  */
 export interface BidirectionalRule<FormBody extends object = object> {
-  /**
-   * Returns the fields that should have bidirectional validation with the current field
-   */
-  getBidirectionalFields(): Array<keyof FormBody>
+    /**
+     * Returns the fields that should have bidirectional validation with the current field
+     */
+    getBidirectionalFields(): Array<keyof FormBody>;
 }

package/dist/vue/forms/validation/types/BidirectionalRule.js

@@ -0,0 +1 @@
+export {};

package/dist/vue/forms/validation/types/ValidationRules.d.ts

@@ -0,0 +1,11 @@
+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;
+    };
+}>>;
+export {};

package/dist/vue/forms/validation/types/ValidationRules.js

@@ -0,0 +1 @@
+export {};

package/dist/vue/index.d.ts

@@ -0,0 +1,11 @@
+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/dist/vue/index.js

@@ -0,0 +1,10 @@
+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 } from './composables/useConfirmDialog';
+export { useIsOpen, useModelWrapper, useOnOpen, useIsOpenFromVar, useGlobalCheckbox, useIsEmpty, useConfirmDialog };
+export { ConfirmDialogSeverity };

package/dist/vue/requests/factories/VueRequestLoaderFactory.d.ts

@@ -0,0 +1,6 @@
+import { type RequestLoaderContract } from '../../../requests/contracts/RequestLoaderContract';
+import { type Ref } from 'vue';
+import type { RequestLoaderFactoryContract } from '../../../requests';
+export declare class VueRequestLoaderFactory implements RequestLoaderFactoryContract<Ref<boolean>> {
+    make(): RequestLoaderContract<Ref<boolean>>;
+}

package/dist/vue/requests/factories/VueRequestLoaderFactory.js

@@ -0,0 +1,6 @@
+import { VueRequestLoader } from '../loaders/VueRequestLoader';
+export class VueRequestLoaderFactory {
+    make() {
+        return new VueRequestLoader();
+    }
+}

package/{src/vue/requests/index.ts → dist/vue/requests/index.d.ts}

@@ -1,5 +1,4 @@
-import { VueRequestLoader } from './loaders/VueRequestLoader'
-import { VueRequestBatchLoader } from './loaders/VueRequestBatchLoader'
-import { VueRequestLoaderFactory } from './factories/VueRequestLoaderFactory'
-
-export { VueRequestLoader, VueRequestBatchLoader, VueRequestLoaderFactory }
+import { VueRequestLoader } from './loaders/VueRequestLoader';
+import { VueRequestBatchLoader } from './loaders/VueRequestBatchLoader';
+import { VueRequestLoaderFactory } from './factories/VueRequestLoaderFactory';
+export { VueRequestLoader, VueRequestBatchLoader, VueRequestLoaderFactory };

package/dist/vue/requests/index.js

@@ -0,0 +1,4 @@
+import { VueRequestLoader } from './loaders/VueRequestLoader';
+import { VueRequestBatchLoader } from './loaders/VueRequestBatchLoader';
+import { VueRequestLoaderFactory } from './factories/VueRequestLoaderFactory';
+export { VueRequestLoader, VueRequestBatchLoader, VueRequestLoaderFactory };

package/dist/vue/requests/loaders/VueRequestBatchLoader.d.ts

@@ -0,0 +1,12 @@
+import { type Ref } from 'vue';
+import { type RequestLoaderContract } from '../../../requests/contracts/RequestLoaderContract';
+export declare class VueRequestBatchLoader implements RequestLoaderContract<Ref<boolean>> {
+    private inFlight;
+    private completed;
+    private expected;
+    constructor(expectedRequests?: number);
+    startBatch(count: number): void;
+    abortBatch(): void;
+    isLoading(): Ref<boolean>;
+    setLoading(loading: boolean): void;
+}

package/dist/vue/requests/loaders/VueRequestBatchLoader.js

@@ -0,0 +1,29 @@
+import { ref, computed } from 'vue';
+export class VueRequestBatchLoader {
+    constructor(expectedRequests = 0) {
+        this.inFlight = ref(0);
+        this.completed = ref(0);
+        this.expected = 0;
+        this.expected = expectedRequests;
+    }
+    startBatch(count) {
+        this.expected = count;
+        this.completed.value = 0;
+    }
+    abortBatch() {
+        this.expected = 0;
+        this.completed.value = 0;
+    }
+    isLoading() {
+        return computed(() => this.inFlight.value > 0 || (this.expected > 0 && this.completed.value < this.expected));
+    }
+    setLoading(loading) {
+        if (loading) {
+            this.inFlight.value++;
+        }
+        else {
+            this.inFlight.value = Math.max(0, this.inFlight.value - 1);
+            this.completed.value++;
+        }
+    }
+}

package/dist/vue/requests/loaders/VueRequestLoader.d.ts

@@ -0,0 +1,8 @@
+import { type Ref } from 'vue';
+import { type RequestLoaderContract } from '../../../requests/contracts/RequestLoaderContract';
+export declare class VueRequestLoader implements RequestLoaderContract<Ref<boolean>> {
+    protected loading: Ref<boolean>;
+    constructor(initialLoading?: boolean);
+    isLoading(): Ref<boolean>;
+    setLoading(value: boolean): void;
+}

package/dist/vue/requests/loaders/VueRequestLoader.js

@@ -0,0 +1,12 @@
+import { ref } from 'vue';
+export class VueRequestLoader {
+    constructor(initialLoading = false) {
+        this.loading = ref(initialLoading);
+    }
+    isLoading() {
+        return this.loading;
+    }
+    setLoading(value) {
+        this.loading.value = value;
+    }
+}