@arrai-innovations/reactive-helpers 20.1.2 → 21.0.0

package/types/use/listRelated.d.ts

@@ -1,3 +1,72 @@
+/**
+ * Vue Composition API composable function for managing relationships among objects in a list.
+ * It enables linking objects based on predefined rules and dynamically adjusts as the underlying data changes.
+ *
+ * @module use/listRelated.js
+ */
+/**
+ * The rule for defining relationships for objects in a list.
+ *
+ * @typedef {object} ListRelatedRule
+ * @property {string} pkKey - Specifies the foreign key used to link objects across lists. Planned to be renamed to
+ *  'fkKey' to better reflect its usage.
+ * @property {string[]} [order] - Specifies the order in which related objects should be sorted, if applicable.
+ * @property {import('./listInstance.js').ObjectsByPk} objects - The objects that can be related based on the foreign key.
+ */
+/**
+ * The rules for defining relationships among objects in a list.
+ *
+ * @typedef {{
+ *     [rule: string]: ListRelatedRule,
+ * }} ListRelatedRules
+ */
+/**
+ * Represents the internal state used by the list related composition function. It manages and computes the relationships
+ * between objects based on specified rules, providing real-time updates to related objects as the parent state changes.
+ *
+ * @typedef {object} ListRelatedRawState
+ * @property {{
+ *     [pk: string]: {
+ *         [rule: string]: import('vue').ComputedRef<any>,
+ *     },
+ * }} relatedObjects - Stores computed references to related objects, allowing for dynamic access based on object pk and specific rules.
+ * @property {ListRelatedRules} relatedObjectsRules - Defines the rules for establishing relationships, such as foreign key links and sorting orders.
+ * @property {{
+ *     [pk: string]: {
+ *         [rule: string]: import('vue').ComputedRef<[object, string]>,
+ *     },
+ * }} objAndKeyForPkAndRule - Maps each object pk and rule to a tuple consisting of the related object and its respective key, facilitating direct data manipulation.
+ * @property {{
+ *     [pk: string]: {
+ *         [rule: string]: import('vue').ComputedRef<any>,
+ *     },
+ * }} fkForPkAndRule - Maintains computed references to the foreign keys for each object pk and rule, crucial for navigating complex data relationships.
+ * @property {boolean} relatedObjectsParentStateObjectsWatchRunning - Flags whether the watch on parent state objects is currently active, ensuring updates trigger as needed.
+ * @property {boolean} relatedObjectsWatchRunning - Indicates if watches on the related objects themselves are active, managing updates efficiently.
+ * @property {boolean} relatedRunning - Signals whether any computations related to object relationships are currently in progress.
+ * @property {import('vue').Ref<boolean>} running - General flag that indicates if the list-related logic is processing, used to manage UI feedback or prevent concurrent operations.
+ */
+/**
+ * The raw state properties for a parent of a list related property.
+ *
+ * @typedef {(
+ *     import('./listInstance.js').ListInstanceRawState &
+ *     Partial<import('./listSubscription.js').ListSubscriptionRawState>
+ * )} ListRelatedParentRawState
+ */
+/**
+ * The type for a parentState object.
+ *
+ * @typedef {import('vue').UnwrapNestedRefs<ListRelatedParentRawState>} ListRelatedParentState
+ */
+/**
+ * The state for a list related property.
+ *
+ * @typedef {import('vue').UnwrapNestedRefs<
+ *     ListRelatedParentRawState &
+ *     ListRelatedRawState
+ * >} ListRelatedState
+ */
 /**
  * The options for the list related composition function.
  *
@@ -11,8 +80,7 @@
  * @typedef {object} ListRelatedProperties
  * @property {ListRelatedState} state - The state for the list related property.
  * @property {ListRelatedParentState} parentState - The parent state object.
- * @property {import('./watchesRunning.js').WatchesRunning} watchesRunning - The watches running instance.
- * @property {import('vue').EffectScope} effectScope - The effect scope for the list related property.
+ * @property {() => void} stop - Stops all effects of the list related property.
  */
 /**
  * An instance of `useListRelated`.
@@ -109,44 +177,6 @@ export function useListRelateds(listRelatedArgs: {
  * maintaining the integrity of object relationships as per the specified rules.
  */
 export function useListRelated({ parentState, relatedObjectsRules }: ListRelatedOptions): ListRelated;
-/**
- * The options for the list related composition function.
- */
-export type ListRelatedOptions = {
-    /**
-     * - The parent state object.
-     */
-    parentState: ListRelatedParentState;
-    /**
-     * - The rules for the related objects.
-     */
-    relatedObjectsRules: import("vue").Ref<ListRelatedRules>;
-};
-/**
- * The properties for the list related composition function.
- */
-export type ListRelatedProperties = {
-    /**
-     * - The state for the list related property.
-     */
-    state: ListRelatedState;
-    /**
-     * - The parent state object.
-     */
-    parentState: ListRelatedParentState;
-    /**
-     * - The watches running instance.
-     */
-    watchesRunning: import("./watchesRunning.js").WatchesRunning;
-    /**
-     * - The effect scope for the list related property.
-     */
-    effectScope: import("vue").EffectScope;
-};
-/**
- * An instance of `useListRelated`.
- */
-export type ListRelated = ListRelatedProperties;
 /**
  * The rule for defining relationships for objects in a list.
  */
@@ -168,9 +198,9 @@ export type ListRelatedRule = {
 /**
  * The rules for defining relationships among objects in a list.
  */
-export type ListRelatedRules = import("vue").UnwrapNestedRefs<{
+export type ListRelatedRules = {
     [rule: string]: ListRelatedRule;
-}>;
+};
 /**
  * Represents the internal state used by the list related composition function. It manages and computes the relationships
  * between objects based on specified rules, providing real-time updates to related objects as the parent state changes.
@@ -233,4 +263,37 @@ export type ListRelatedParentState = import("vue").UnwrapNestedRefs<ListRelatedP
  * The state for a list related property.
  */
 export type ListRelatedState = import("vue").UnwrapNestedRefs<ListRelatedParentRawState & ListRelatedRawState>;
-//# sourceMappingURL=listRelated.d.ts.map
+/**
+ * The options for the list related composition function.
+ */
+export type ListRelatedOptions = {
+    /**
+     * - The parent state object.
+     */
+    parentState: ListRelatedParentState;
+    /**
+     * - The rules for the related objects.
+     */
+    relatedObjectsRules: import("vue").Ref<ListRelatedRules>;
+};
+/**
+ * The properties for the list related composition function.
+ */
+export type ListRelatedProperties = {
+    /**
+     * - The state for the list related property.
+     */
+    state: ListRelatedState;
+    /**
+     * - The parent state object.
+     */
+    parentState: ListRelatedParentState;
+    /**
+     * - Stops all effects of the list related property.
+     */
+    stop: () => void;
+};
+/**
+ * An instance of `useListRelated`.
+ */
+export type ListRelated = ListRelatedProperties;

package/types/use/listSearch.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Provides a Vue 3 composable for adding text search functionality to lists. It allows for
+ * configuring dynamic search rules that reactively filter lists based on user input and other
+ * criteria. The search functionality is optimized for integration with other list management
+ * composables like listInstance and listFilter, enabling complex search scenarios across
+ * multiple data points.
+ *
+ * @module use/listSearch.js
+ */
 /**
  * Represents the raw reactive state used by the list search functionality.
  *
@@ -11,8 +20,8 @@
  * @property {object} objectIndexes - Indexes built for quick search across objects based on rules.
  * @property {object} customDocumentOptions - Configuration options for the search document, used by FlexSearch.
  * @property {object} customSearchOptions - Additional search options for FlexSearch.
- * @property {boolean} searched - Flag indicating if a search has been performed.
- * @property {boolean} running - Indicates if the search process is actively running.
+ * @property {Readonly<import('vue').Ref<boolean>>} searched - Flag indicating if a search has been performed.
+ * @property {import('vue').ComputedRef<boolean>} running - Indicates if the search process is actively running.
  */
 /**
  *
@@ -28,6 +37,9 @@
 /**
  * @typedef {import('vue').UnwrapNestedRefs<ListSearchParentRawState>} ListSearchParentState - The parent state for a list search.
  */
+/**
+ *  @typedef {import('vue').ToRefs<ListSearchParentState>} ListSearchParentStateToRefs
+ */
 /**
  * @typedef {import('vue').UnwrapNestedRefs<
  *     ListSearchRawState &
@@ -58,8 +70,8 @@
  *
  * @typedef {object} ListSearchProperties
  * @property {ListSearchState} state - The state.
- * @property {import('vue').EffectScope} effectScope - The effect scope.
  * @property {import('./search.js').SearchInstance} textSearchIndex - The text search index.
+ * @property {() => void} stop - Stops the effect scope and cleans up resources.
  */
 /**
  * The provided list search instance, containing properties and functions.
@@ -99,7 +111,7 @@ export function useListSearches(listSearchArgs: {
 /**
  * @typedef {object} ListSearchInstanceOptions
  * @property {object} parentState - The list being filtered.
- * @property {ListSearchProps} props - Reactive properties.
+ * @property {ListSearchProps} [props] - Reactive properties.
  * @property {number} [throttle=500] - Throttle wait time.
  * @property {boolean} [showAllWhenEmpty=true] - Whether to show all items when the search is empty.
  */
@@ -172,17 +184,18 @@ export type ListSearchRawState = {
     /**
      * - Flag indicating if a search has been performed.
      */
-    searched: boolean;
+    searched: Readonly<import("vue").Ref<boolean>>;
     /**
      * - Indicates if the search process is actively running.
      */
-    running: boolean;
+    running: import("vue").ComputedRef<boolean>;
 };
 export type ListSearchParentRawState = (import("./listInstance.js").ListInstanceRawState & Partial<import("./listSubscription.js").ListSubscriptionRawState> & Partial<import("./listRelated.js").ListRelatedRawState> & Partial<import("./listCalculated.js").ListCalculatedRawState> & Partial<import("./listFilter.js").ListFilterRawState>);
 /**
  * - The parent state for a list search.
  */
 export type ListSearchParentState = import("vue").UnwrapNestedRefs<ListSearchParentRawState>;
+export type ListSearchParentStateToRefs = import("vue").ToRefs<ListSearchParentState>;
 /**
  * - The state for a list search.
  */
@@ -239,14 +252,14 @@ export type ListSearchProperties = {
      * - The state.
      */
     state: ListSearchState;
-    /**
-     * - The effect scope.
-     */
-    effectScope: import("vue").EffectScope;
     /**
      * - The text search index.
      */
     textSearchIndex: import("./search.js").SearchInstance;
+    /**
+     * - Stops the effect scope and cleans up resources.
+     */
+    stop: () => void;
 };
 /**
  * The provided list search instance, containing properties and functions.
@@ -285,7 +298,7 @@ export type ListSearchInstanceOptions = {
     /**
      * - Reactive properties.
      */
-    props: ListSearchProps;
+    props?: ListSearchProps;
     /**
      * - Throttle wait time.
      */
@@ -295,4 +308,3 @@ export type ListSearchInstanceOptions = {
      */
     showAllWhenEmpty?: boolean;
 };
-//# sourceMappingURL=listSearch.d.ts.map

package/types/use/listSort.d.ts

@@ -28,12 +28,7 @@ export function setListSortDefaultOptions({ sortThrottleWait }: {
  *
  * @typedef {object} ListSortRawState
  * @property {OrderByRule[]} orderByRules - Current sorting rules applied to the list.
- * @property {string[]} order - Array of IDs representing the current sort order of the list.
- * @property {object} sortCriteria - Computed sort criteria used for dynamically sorting the list.
  * @property {boolean[]} orderByDesc - Flags indicating whether each sort criterion is in descending order.
- * @property {boolean} sortCriteriaWatchRunning - Flag to indicate if sorting criteria computations are actively updating.
- * @property {boolean} sortWatchRunning - Flag to indicate if the sort operation is actively processing.
- * @property {boolean} outstandingEffects - Flag to indicate if there are pending reactive effects needing resolution.
  */
 /**
  *
@@ -73,8 +68,7 @@ export function setListSortDefaultOptions({ sortThrottleWait }: {
  * @typedef {object} ListSortProperties
  * @property {ListSortState} state - The reactive state for the list sort.
  * @property {ListSortParentState} parentState - The parent state.
- * @property {import('vue').EffectScope} effectScope - The effect scope for the list sort.
- * @property {import('./watchesRunning.js').WatchesRunning} watchesRunning - The watches running instance.
+ * @property {() => void} stop - A function to stop the effect scope and clean up resources.
  */
 /**
  * The list sort instance, including reactive state and utilities to manage list sorting operations.
@@ -157,30 +151,10 @@ export type ListSortRawState = {
      * - Current sorting rules applied to the list.
      */
     orderByRules: OrderByRule[];
-    /**
-     * - Array of IDs representing the current sort order of the list.
-     */
-    order: string[];
-    /**
-     * - Computed sort criteria used for dynamically sorting the list.
-     */
-    sortCriteria: object;
     /**
      * - Flags indicating whether each sort criterion is in descending order.
      */
     orderByDesc: boolean[];
-    /**
-     * - Flag to indicate if sorting criteria computations are actively updating.
-     */
-    sortCriteriaWatchRunning: boolean;
-    /**
-     * - Flag to indicate if the sort operation is actively processing.
-     */
-    sortWatchRunning: boolean;
-    /**
-     * - Flag to indicate if there are pending reactive effects needing resolution.
-     */
-    outstandingEffects: boolean;
 };
 export type ListSortParentRawState = (import("./listInstance.js").ListInstanceRawState & Partial<import("./listSubscription.js").ListSubscriptionRawState> & Partial<import("./listRelated.js").ListRelatedRawState> & Partial<import("./listCalculated.js").ListCalculatedRawState> & Partial<import("./listFilter.js").ListFilterRawState> & Partial<import("./listSearch.js").ListSearchRawState>);
 export type ListSortParentState = import("vue").UnwrapNestedRefs<ListSortParentRawState>;
@@ -219,16 +193,11 @@ export type ListSortProperties = {
      */
     parentState: ListSortParentState;
     /**
-     * - The effect scope for the list sort.
-     */
-    effectScope: import("vue").EffectScope;
-    /**
-     * - The watches running instance.
+     * - A function to stop the effect scope and clean up resources.
      */
-    watchesRunning: import("./watchesRunning.js").WatchesRunning;
+    stop: () => void;
 };
 /**
  * The list sort instance, including reactive state and utilities to manage list sorting operations.
  */
 export type ListSort = ListSortProperties;
-//# sourceMappingURL=listSort.d.ts.map

package/types/use/listSubscription.d.ts

@@ -1,29 +1,37 @@
 /**
  * The raw state of a list subscription.
  *
- * @typedef {object} ListSubscriptionRawState
- * @property {Readonly<import('vue').Ref<boolean>>} subscriptionLoading - Whether the subscription is loading.
- * @property {Readonly<import('vue').Ref<boolean>>} subscriptionErrored - Whether the subscription has errored.
- * @property {Readonly<import('vue').Ref<Error>>} subscriptionError - The error that occurred.
- * @property {boolean} intendToList - If this is true, the list should be fetched, or re-fetched if arguments change.
- * @property {boolean} intendToSubscribe - If this is true, the subscription should start or restart if arguments change.
- * @property {boolean} subscribed - Whether the subscription is active.
+ * @typedef {object} ListSubscriptionMyState
+ * @property {import('vue').Ref<boolean>|boolean} intendToList - If this is true, the list should be fetched, or re-fetched if arguments change.
+ * @property {import('vue').Ref<boolean>|boolean} intendToSubscribe - If this is true, the subscription should start or restart if arguments change.
+ * @property {import('vue').Ref<boolean>} subscribed - Whether the subscription is active.
+ */
+/**
+ * @typedef {import('vue').ToRefs<import('./listInstance.js').ListInstanceState>} ListInstanceStateRefs
+ */
+/**
+ * The raw state of a list subscription, including the state from the list instance.
+ *
+ * @typedef {ListSubscriptionMyState & (
+ *     Pick<import('./loadingError.js').LoadingErrorStatus, "loading" | "error" | "errored">
+ * ) & ListInstanceStateRefs} ListSubscriptionRawState
  */
 /**
  * A reactive object that manages a list of objects, as returned by `useListInstance`.
  *
- * @typedef {import('vue').UnwrapNestedRefs<
- *     ListSubscriptionRawState &
- *     import('./listInstance.js').ListInstanceRawState
- * >} ListSubscriptionState
+ * @typedef {import('vue').Reactive<ListSubscriptionRawState>} ListSubscriptionState
  */
 /**
  * The methods available on a list subscription.
  *
- * @typedef {object} ListSubscriptionFunctions
- * @property {Function} subscribe - Trigger a subscription to the list.
- * @property {Function} unsubscribe - Unsubscribe from the list.
- * @property {Function} clearError - Clear the subscription error and the underlying list instance error.
+ * @typedef {Pick<import('./loadingError.js').LoadingErrorStatus, "clearError">} ListSubscriptionFunctions
+ */
+/**
+ * @typedef {{
+ *     state: ListSubscriptionState,
+ *     listInstance: import('./listInstance.js').ListInstance,
+ *     loadingError: import('./loadingError.js').LoadingErrorStatus,
+ * }} ListSubscriptionContext
  */
 /**
  * The properties of a list subscription.
@@ -33,7 +41,6 @@
  * @property {import('./listInstance.js').ListInstance} listInstance - The list instance used by the subscription.
  * @property {import('./cancellableIntent.js').CancellableIntent} listIntent - The `CancellableIntent` instance managing if the list should be (re)fetched.
  * @property {import('./cancellableIntent.js').CancellableIntent} subscribeIntent - The `CancellableIntent` instance managing if the subscription should be (un)subscribed.
- * @property {import('vue').EffectScope} effectScope - The effect scope of the list subscription.
  */
 /**
  * An instance of a list subscription, returned by `useListSubscription`.
@@ -46,8 +53,6 @@
  *
  * @typedef {object & import("./listInstance.js").ListInstanceOptions} ListSubscriptionOptions
  * @property {import("./listInstance.js").ListInstance} listInstance - A list instance to use instead of creating one.
- * @property {boolean} clearListOnListIntentTriggered - If true, the list will be cleared when the list intent is triggered. Default is false.
- * @property {import('vue').Ref<boolean>|boolean} keepOldPages - If true, pages will not be cleared when defaultPageCallback is called.
  */
 /**
  * A Vue composition function that creates multiple list subscriptions, and returns them as an object.
@@ -105,11 +110,9 @@ export function useListSubscriptions(listSubscriptionArgs: {
  * @param {ListSubscriptionOptions} options - The options for the list subscription.
  * @returns {ListSubscription} - Returns a robust list subscription object that manages a list instance with
  *  capabilities to subscribe and unsubscribe to data sources, alongside handling real-time data updates.
- * @throws {ListSubscriptionError} - If both listInstance and props are passed, or if neither are
- * passed. Also thrown if clearListOnListIntentTriggered is not passed or if neither listInstance
- * nor keepOldPages are passed.
+ * @throws {ListSubscriptionError} - If the list instance is not set and no props are passed.
  */
-export function useListSubscription({ listInstance, props, handlers, keepOldPages, clearListOnListIntentTriggered }: ListSubscriptionOptions): ListSubscription;
+export function useListSubscription({ listInstance, props, handlers }: ListSubscriptionOptions): ListSubscription;
 /**
  * A composable function for managing a list subscription.
  *
@@ -131,52 +134,37 @@ export class ListSubscriptionError extends Error {
 /**
  * The raw state of a list subscription.
  */
-export type ListSubscriptionRawState = {
-    /**
-     * - Whether the subscription is loading.
-     */
-    subscriptionLoading: Readonly<import("vue").Ref<boolean>>;
-    /**
-     * - Whether the subscription has errored.
-     */
-    subscriptionErrored: Readonly<import("vue").Ref<boolean>>;
-    /**
-     * - The error that occurred.
-     */
-    subscriptionError: Readonly<import("vue").Ref<Error>>;
+export type ListSubscriptionMyState = {
     /**
      * - If this is true, the list should be fetched, or re-fetched if arguments change.
      */
-    intendToList: boolean;
+    intendToList: import("vue").Ref<boolean> | boolean;
     /**
      * - If this is true, the subscription should start or restart if arguments change.
      */
-    intendToSubscribe: boolean;
+    intendToSubscribe: import("vue").Ref<boolean> | boolean;
     /**
      * - Whether the subscription is active.
      */
-    subscribed: boolean;
+    subscribed: import("vue").Ref<boolean>;
 };
+export type ListInstanceStateRefs = import("vue").ToRefs<import("./listInstance.js").ListInstanceState>;
+/**
+ * The raw state of a list subscription, including the state from the list instance.
+ */
+export type ListSubscriptionRawState = ListSubscriptionMyState & (Pick<import("./loadingError.js").LoadingErrorStatus, "loading" | "error" | "errored">) & ListInstanceStateRefs;
 /**
  * A reactive object that manages a list of objects, as returned by `useListInstance`.
  */
-export type ListSubscriptionState = import("vue").UnwrapNestedRefs<ListSubscriptionRawState & import("./listInstance.js").ListInstanceRawState>;
+export type ListSubscriptionState = import("vue").Reactive<ListSubscriptionRawState>;
 /**
  * The methods available on a list subscription.
  */
-export type ListSubscriptionFunctions = {
-    /**
-     * - Trigger a subscription to the list.
-     */
-    subscribe: Function;
-    /**
-     * - Unsubscribe from the list.
-     */
-    unsubscribe: Function;
-    /**
-     * - Clear the subscription error and the underlying list instance error.
-     */
-    clearError: Function;
+export type ListSubscriptionFunctions = Pick<import("./loadingError.js").LoadingErrorStatus, "clearError">;
+export type ListSubscriptionContext = {
+    state: ListSubscriptionState;
+    listInstance: import("./listInstance.js").ListInstance;
+    loadingError: import("./loadingError.js").LoadingErrorStatus;
 };
 /**
  * The properties of a list subscription.
@@ -198,10 +186,6 @@ export type ListSubscriptionProperties = {
      * - The `CancellableIntent` instance managing if the subscription should be (un)subscribed.
      */
     subscribeIntent: import("./cancellableIntent.js").CancellableIntent;
-    /**
-     * - The effect scope of the list subscription.
-     */
-    effectScope: import("vue").EffectScope;
 };
 /**
  * An instance of a list subscription, returned by `useListSubscription`.
@@ -212,4 +196,3 @@ export type ListSubscription = ListSubscriptionFunctions & ListSubscriptionPrope
  *  and subscriptions based on the given properties.
  */
 export type ListSubscriptionOptions = object & import("./listInstance.js").ListInstanceOptions;
-//# sourceMappingURL=listSubscription.d.ts.map

package/types/use/loading.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @typedef {import("vue").Ref<boolean|undefined>} LoadingRef
+ * @typedef {Readonly<LoadingRef>} LoadingReadonlyRef
+ */
+/**
+ * The loading state API.
+ *
+ * @typedef {object} LoadingStatus
+ * @property {LoadingReadonlyRef} loading - Whether the component is loading.
+ * @property {() => void} setLoading - Set the loading state to true.
+ * @property {() => void} clearLoading - Set the loading state to false.
+ */
+/**
+ * A composable function for managing loading state.
+ *
+ * @returns {LoadingStatus} - An object containing reactive fields and actions for loading state.
+ */
+export function useLoading(): LoadingStatus;
+export type LoadingRef = import("vue").Ref<boolean | undefined>;
+export type LoadingReadonlyRef = Readonly<LoadingRef>;
+/**
+ * The loading state API.
+ */
+export type LoadingStatus = {
+    /**
+     * - Whether the component is loading.
+     */
+    loading: LoadingReadonlyRef;
+    /**
+     * - Set the loading state to true.
+     */
+    setLoading: () => void;
+    /**
+     * - Set the loading state to false.
+     */
+    clearLoading: () => void;
+};

package/types/use/loadingError.d.ts

@@ -1,105 +1,10 @@
 /**
- * @module use/loadingError.js - A composable function for managing loading and error states.
+ * @typedef {import('./loading.js').LoadingStatus & import('./error.js').ErrorStatus} LoadingErrorStatus
  */
 /**
- * @typedef {() => void} ClearErrorFn - Clear the error state.
- */
-/**
- * @typedef {import("vue").Ref<boolean|undefined>} LoadingRef
- */
-/**
- * @typedef {import("vue").Ref<Error|null>} ErrorRef
- */
-/**
- * @typedef {import("vue").Ref<boolean>} ErroredRef
- */
-/**
- * @typedef {Readonly<LoadingRef>} LoadingReadonlyRef
- */
-/**
- * @typedef {Readonly<ErrorRef>} ErrorReadonlyRef
- */
-/**
- * @typedef {Readonly<ErroredRef>} ErroredReadonlyRef
- */
-/**
- * The common API for loading and error states.
+ * A composable function combining loading and error state management.
  *
- * @typedef {object} LoadingErrorStatus
- * @property {LoadingReadonlyRef} loading - Whether the component is loading.
- * @property {ErrorReadonlyRef} error - The error that occurred.
- * @property {ErroredReadonlyRef} errored - Whether an error has occurred.
- * @property {ClearErrorFn} clearError - Clear the error state.
- */
-/**
- * The writable API for loading and error states.
- *
- * @typedef {object} LoadingErrorMutations
- * @property {() => void} setLoading - Set the loading state.
- * @property {() => void} clearLoading - Clear the loading state.
- * @property {(error: Error) => void} setError - Set the error state.
- */
-/**
- * The instance of useLoadingError.
- *
- * @typedef {LoadingErrorStatus & LoadingErrorMutations} LoadingError
- */
-/**
- * A composable function for managing loading and error states.
- *
- * @returns {LoadingError} - An object containing reactive fields and actions for loading and error states.
- */
-export function useLoadingError(): LoadingError;
-/**
- * - Clear the error state.
- */
-export type ClearErrorFn = () => void;
-export type LoadingRef = import("vue").Ref<boolean | undefined>;
-export type ErrorRef = import("vue").Ref<Error | null>;
-export type ErroredRef = import("vue").Ref<boolean>;
-export type LoadingReadonlyRef = Readonly<LoadingRef>;
-export type ErrorReadonlyRef = Readonly<ErrorRef>;
-export type ErroredReadonlyRef = Readonly<ErroredRef>;
-/**
- * The common API for loading and error states.
- */
-export type LoadingErrorStatus = {
-    /**
-     * - Whether the component is loading.
-     */
-    loading: LoadingReadonlyRef;
-    /**
-     * - The error that occurred.
-     */
-    error: ErrorReadonlyRef;
-    /**
-     * - Whether an error has occurred.
-     */
-    errored: ErroredReadonlyRef;
-    /**
-     * - Clear the error state.
-     */
-    clearError: ClearErrorFn;
-};
-/**
- * The writable API for loading and error states.
- */
-export type LoadingErrorMutations = {
-    /**
-     * - Set the loading state.
-     */
-    setLoading: () => void;
-    /**
-     * - Clear the loading state.
-     */
-    clearLoading: () => void;
-    /**
-     * - Set the error state.
-     */
-    setError: (error: Error) => void;
-};
-/**
- * The instance of useLoadingError.
+ * @returns {LoadingErrorStatus} - An object containing reactive fields and actions for both loading and error state.
  */
-export type LoadingError = LoadingErrorStatus & LoadingErrorMutations;
-//# sourceMappingURL=loadingError.d.ts.map
+export function useLoadingError(): LoadingErrorStatus;
+export type LoadingErrorStatus = import("./loading.js").LoadingStatus & import("./error.js").ErrorStatus;