@arrai-innovations/reactive-helpers 18.0.1 → 18.0.2

package/types/use/listSort.d.ts

@@ -0,0 +1,235 @@
+/**
+ * Sets default configuration options for all list sorting operations within the application. This function allows
+ * global settings to be specified that affect the behavior of sorting operations unless overridden by specific
+ * instance configurations.
+ *
+ * @param {object} options - Configuration options to set as defaults for list sorting.
+ * @param {number} options.sortThrottleWait - Default throttle wait time, in milliseconds, to control the rate at
+ * which sorting operations are processed, enhancing performance on large lists.
+ */
+export function setListSortDefaultOptions({ sortThrottleWait }: {
+    sortThrottleWait: number;
+}): void;
+/**
+ * Describes a rule for ordering elements in a list. Each rule can directly reference a property of the list items,
+ * or define a function to compute the value used for sorting. Rules can be configured to sort in ascending or descending
+ * order and can utilize locale-aware string comparison if necessary.
+ *
+ * @typedef {{
+ *     key: string,
+ *     keyFn?: (object: any, state: ListSortState) => any,
+ *     desc?: boolean,
+ *     localeCompare?: boolean
+ * }} OrderByRule
+ */
+/**
+ * Represents the raw state used by the list sorting functionality. Includes all configurations and state necessary
+ * to manage sorting operations within a Vue application.
+ *
+ * @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.
+ */
+/**
+ *
+ *
+ * @typedef {(
+ *     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>
+ * )} ListSortParentRawState
+ */
+/**
+ * @typedef {import('vue').UnwrapNestedRefs<ListSortParentRawState>} ListSortParentState
+ */
+/**
+ * The reactive state used by the list sorting functionality. Includes all configurations and state necessary to manage
+ * sorting operations within a Vue application.
+ *
+ * @typedef {import('vue').UnwrapNestedRefs<
+ *     ListSortParentRawState &
+ *     ListSortRawState
+ * >} ListSortState
+ */
+/**
+ * The configuration options for initializing a list sort instance.
+ *
+ * @typedef {object} ListSortOptions
+ * @property {ListSortParentState} parentState - The parent state containing the list data and any associated state needed for sorting.
+ * @property {OrderByRule[]|import('vue').Ref<OrderByRule[]>} orderByRules - Rules defining how the list should be sorted, including key and direction.
+ * @property {number | symbol} sortThrottleWait - Optional throttle wait time to limit the frequency of sort operations, enhancing performance.
+ */
+/**
+ * The properties available on a list sort instance.
+ *
+ * @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.
+ */
+/**
+ * The list sort instance, including reactive state and utilities to manage list sorting operations.
+ *
+ * @typedef {ListSortProperties} ListSort
+ */
+/**
+ * Creates multiple list sort instances.
+ *
+ * @param {{
+ *     [keys: string]: ListSortOptions,
+ * }} listSortArgs - The options for the list sort.
+ * @returns {{
+ *     [keys: string]: ListSort
+ * }} The list sort instance.
+ */
+export function useListSorts(listSortArgs: {
+    [keys: string]: ListSortOptions;
+}): {
+    [keys: string]: ListSort;
+};
+/**
+ * Initializes and manages sorting for a list of objects. This function sets up a reactive sorting mechanism
+ * that automatically updates the sort order of the list based on specified criteria. It supports multiple sorting
+ * rules, including direct property comparison and custom comparator functions, providing flexibility in handling
+ * various data types and structures.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { reactive, computed } from 'vue';
+ * import { useListSort, useListInstance } from '@arrai-innovations/reactive-helpers';
+ * const listInstanceProps = reactive({
+ *     crudArgs: {},
+ *     listArgs: {},
+ *     pkKey: 'id',
+ *     retrieveArgs: {},
+ *     intendToList: true,
+ * });
+ * const listInstance = useListInstance(listInstanceProps);
+ * const listSortProps = reactive({
+ *     parentState: listInstance.state, // Providing the list instance state as the parent state
+ *     orderByRules: [
+ *         { key: 'name', desc: false }, // Sort by name in ascending order
+ *         { key: 'age', desc: true }, // Sort by age in descending order
+ *         { key: 'relatedItem.name', desc: false }, // Sort by a related item's name
+ *         { key: 'calculatedItem.value', desc: true }, // Sort by a calculated value in descending order
+ *     ],
+ * });
+ * const listSort = useListSort(listSortProps);
+ * </script>
+ * <template>
+ *     <!-- reactive list of items sorted client-side -->
+ *     <div v-for="item in listSort.state.objectsInOrder" :key="item.id">
+ *         {{ item.name }}
+ *     </div>
+ * </template>
+ * ```
+ *
+ * @param {ListSortOptions} options - The configuration options for initializing the list sort instance.
+ * @returns {ListSort} The initialized list sort instance, including reactive state and utilities to manage list sorting.
+ */
+export function useListSort({ parentState, orderByRules, sortThrottleWait }: ListSortOptions): ListSort;
+/**
+ * Describes a rule for ordering elements in a list. Each rule can directly reference a property of the list items,
+ * or define a function to compute the value used for sorting. Rules can be configured to sort in ascending or descending
+ * order and can utilize locale-aware string comparison if necessary.
+ */
+export type OrderByRule = {
+    key: string;
+    keyFn?: (object: any, state: ListSortState) => any;
+    desc?: boolean;
+    localeCompare?: boolean;
+};
+/**
+ * Represents the raw state used by the list sorting functionality. Includes all configurations and state necessary
+ * to manage sorting operations within a Vue application.
+ */
+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>;
+/**
+ * The reactive state used by the list sorting functionality. Includes all configurations and state necessary to manage
+ * sorting operations within a Vue application.
+ */
+export type ListSortState = import("vue").UnwrapNestedRefs<ListSortParentRawState & ListSortRawState>;
+/**
+ * The configuration options for initializing a list sort instance.
+ */
+export type ListSortOptions = {
+    /**
+     * - The parent state containing the list data and any associated state needed for sorting.
+     */
+    parentState: ListSortParentState;
+    /**
+     * - Rules defining how the list should be sorted, including key and direction.
+     */
+    orderByRules: OrderByRule[] | import("vue").Ref<OrderByRule[]>;
+    /**
+     * - Optional throttle wait time to limit the frequency of sort operations, enhancing performance.
+     */
+    sortThrottleWait: number | symbol;
+};
+/**
+ * The properties available on a list sort instance.
+ */
+export type ListSortProperties = {
+    /**
+     * - The reactive state for the list sort.
+     */
+    state: ListSortState;
+    /**
+     * - The parent state.
+     */
+    parentState: ListSortParentState;
+    /**
+     * - The effect scope for the list sort.
+     */
+    effectScope: import("vue").EffectScope;
+    /**
+     * - The watches running instance.
+     */
+    watchesRunning: import("./watchesRunning.js").WatchesRunning;
+};
+/**
+ * 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/listSort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listSort.d.ts","sourceRoot":"","sources":["../../use/listSort.js"],"names":[],"mappings":"AAsDA;;;;;;;;GAQG;AACH,gEAHG;IAAwB,gBAAgB,EAAhC,MAAM;CAEhB,QAGA;AAED;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;GAWG;AAEH;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;GAQG;AAIH;;;;GAIG;AAEH;;;;;;;;;GASG;AACH,2CAPW;IACV,CAAO,IAAI,EAAE,MAAM,GAAG,eAAe,CAAC;CACnC,GACS;IACZ,CAAO,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;CAC3B,CASH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,6EAHW,eAAe,GACb,QAAQ,CAqOpB;;;;;;0BA3WY;IACN,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,aAAa,KAAK,GAAG,CAAC;IACnD,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAA;CAC1B;;;;;;;;;kBAQU,WAAW,EAAE;;;;WACb,MAAM,EAAE;;;;kBACR,MAAM;;;;iBACN,OAAO,EAAE;;;;8BACT,OAAO;;;;sBACP,OAAO;;;;wBACP,OAAO;;qCAMR,CACZ,OAAa,mBAAmB,EAAE,oBAAoB,GAChD,OAAO,CAAC,OAAO,uBAAuB,EAAE,wBAAwB,CAAC,GACjE,OAAO,CAAC,OAAO,kBAAkB,EAAE,mBAAmB,CAAC,GACvD,OAAO,CAAC,OAAO,qBAAqB,EAAE,sBAAsB,CAAC,GAC7D,OAAO,CAAC,OAAO,iBAAiB,EAAE,kBAAkB,CAAC,GACrD,OAAO,CAAC,OAAO,iBAAiB,EAAE,kBAAkB,CAAC,CACxD;kCAIS,OAAO,KAAK,EAAE,gBAAgB,CAAC,sBAAsB,CAAC;;;;;4BAOtD,OAAO,KAAK,EAAE,gBAAgB,CACpC,sBAAsB,GACtB,gBAAgB,CACnB;;;;;;;;iBAOU,mBAAmB;;;;kBACnB,WAAW,EAAE,GAAC,OAAO,KAAK,EAAE,GAAG,CAAC,WAAW,EAAE,CAAC;;;;sBAC9C,MAAM,GAAG,MAAM;;;;;;;;;WAOf,aAAa;;;;iBACb,mBAAmB;;;;iBACnB,OAAO,KAAK,EAAE,WAAW;;;;oBACzB,OAAO,qBAAqB,EAAE,cAAc;;;;;uBAQ7C,kBAAkB"}

package/types/use/listSubscription.d.ts

@@ -0,0 +1,218 @@
+/**
+ * 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.
+ */
+/**
+ * A reactive object that manages a list of objects, as returned by `useListInstance`.
+ *
+ * @typedef {import('vue').UnwrapNestedRefs<
+ *     ListSubscriptionRawState &
+ *     import('./listInstance.js').ListInstanceRawState
+ * >} 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.
+ */
+/**
+ * The properties of a list subscription.
+ *
+ * @typedef {object} ListSubscriptionProperties
+ * @property {ListSubscriptionState} state - The reactive state of the list subscription.
+ * @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`.
+ *
+ * @typedef {ListSubscriptionFunctions & ListSubscriptionProperties} ListSubscription
+ */
+/**
+ * Defines the settings required to establish a list subscription, detailing how list instances should handle updates
+ *  and subscriptions based on the given properties.
+ *
+ * @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 {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.
+ *
+ * @param {{[key: string]: ListSubscriptionOptions}} listSubscriptionArgs - Each desired list instance options, keyed by an instance name.
+ * @returns {{[key: string]: ListSubscription}} - Each list instance, keyed by the instance name.
+ */
+export function useListSubscriptions(listSubscriptionArgs: {
+    [key: string]: ListSubscriptionOptions;
+}): {
+    [key: string]: ListSubscription;
+};
+/**
+ * A composition function that creates a reactive object that manages a list of objects, as returned by
+ * `useListInstance`, causing the list to be re-fetched as needed and listening for updates to the list.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useListSubscription } from "@arrai-innovations/reactive-helpers";
+ * import { reactive, toRef } from "vue";
+ *
+ * const props = defineProps({
+ *     // whatever props are required for your configured list instance
+ *     someListFilter: {
+ *         type: String,
+ *         default: "",
+ *     },
+ * });
+ *
+ * const listSubscriptionProps = reactive({
+ *     crudArgs: {
+ *         // whatever arguments are required for your configured list crud function to get the right endpoint
+ *     },
+ *     listArgs: {
+ *         // whatever arguments are required for your configured list function to get the right list
+ *         someListFilter: toRef(props, "someListFilter"),
+ *     },
+ *     retrieveArgs: {
+ *         // whatever arguments are required for your configured list function to get items back looking as expected
+ *     },
+ *     intendToList: false,
+ *     intendToSubscribe: false,
+ * });
+ * listSubscriptionProps.intendToList = listSubscriptionProps.intendToSubscribe = computed(()=> !!props.someListFilter);
+ * const listSubscription = useListSubscription({ props: listSubscriptionProps });
+ * </script>
+ * <template>
+ *     <ul>
+ *         <!-- reactive list of objects, responding to updates via configured subscription function. -->
+ *         <li v-for="obj in listSubscription.state.objectsInOrder">
+ *             {{ obj }}
+ *         </li>
+ *     </ul>
+ * </template>
+ * ```
+ *
+ * @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.
+ */
+export function useListSubscription({ listInstance, props, functions, keepOldPages, clearListOnListIntentTriggered }: ListSubscriptionOptions): ListSubscription;
+/**
+ * A composable function for managing a list subscription.
+ *
+ * @module use/listSubscription.js
+ */
+/**
+ * Custom error class for list subscription errors.
+ */
+export class ListSubscriptionError extends Error {
+    /**
+     * Creates a new ListSubscriptionError.
+     *
+     * @param {string} message - The error message.
+     * @param {string} code - The error code.
+     */
+    constructor(message: string, code: string);
+    code: string;
+}
+/**
+ * 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>>;
+    /**
+     * - If this is true, the list should be fetched, or re-fetched if arguments change.
+     */
+    intendToList: boolean;
+    /**
+     * - If this is true, the subscription should start or restart if arguments change.
+     */
+    intendToSubscribe: boolean;
+    /**
+     * - Whether the subscription is active.
+     */
+    subscribed: boolean;
+};
+/**
+ * A reactive object that manages a list of objects, as returned by `useListInstance`.
+ */
+export type ListSubscriptionState = import("vue").UnwrapNestedRefs<ListSubscriptionRawState & import("./listInstance.js").ListInstanceRawState>;
+/**
+ * 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;
+};
+/**
+ * The properties of a list subscription.
+ */
+export type ListSubscriptionProperties = {
+    /**
+     * - The reactive state of the list subscription.
+     */
+    state: ListSubscriptionState;
+    /**
+     * - The list instance used by the subscription.
+     */
+    listInstance: import("./listInstance.js").ListInstance;
+    /**
+     * - The `CancellableIntent` instance managing if the list should be (re)fetched.
+     */
+    listIntent: import("./cancellableIntent.js").CancellableIntent;
+    /**
+     * - 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`.
+ */
+export type ListSubscription = ListSubscriptionFunctions & ListSubscriptionProperties;
+/**
+ * Defines the settings required to establish a list subscription, detailing how list instances should handle updates
+ *  and subscriptions based on the given properties.
+ */
+export type ListSubscriptionOptions = object & import("./listInstance.js").ListInstanceOptions;
+//# sourceMappingURL=listSubscription.d.ts.map

package/types/use/listSubscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listSubscription.d.ts","sourceRoot":"","sources":["../../use/listSubscription.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;GAUG;AAEH;;;;;;;GAOG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;GASG;AAEH;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;;;;GAKG;AACH,2DAHW;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,uBAAuB,CAAA;CAAC,GACtC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAAA;CAAC,CAS7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,sHAPW,uBAAuB,GACrB,gBAAgB,CA+R5B;AA5aD;;;;GAIG;AAEH;;GAEG;AACH;IACI;;;;;OAKG;IACH,qBAHW,MAAM,QACN,MAAM,EAMhB;IADG,aAAgB;CAEvB;;;;;;;;yBAMa,QAAQ,CAAC,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;;;;yBACpC,QAAQ,CAAC,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;;;;uBACpC,QAAQ,CAAC,OAAO,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;;;;kBAClC,OAAO;;;;uBACP,OAAO;;;;gBACP,OAAO;;;;;oCAMR,OAAO,KAAK,EAAE,gBAAgB,CACpC,wBAAwB,GAC9B,OAAa,mBAAmB,EAAE,oBAAoB,CACnD;;;;;;;;;;;;;;;;;;;;;;;;;WAgBU,qBAAqB;;;;kBACrB,OAAO,mBAAmB,EAAE,YAAY;;;;gBACxC,OAAO,wBAAwB,EAAE,iBAAiB;;;;qBAClD,OAAO,wBAAwB,EAAE,iBAAiB;;;;iBAClD,OAAO,KAAK,EAAE,WAAW;;;;;+BAM1B,yBAAyB,GAAG,0BAA0B;;;;;sCAOtD,MAAM,GAAG,OAAO,mBAAmB,EAAE,mBAAmB"}

package/types/use/loadingError.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @module use/loadingError.js - A composable function for managing loading and error states.
+ */
+/**
+ * @typedef {() => void} ClearErrorFn - Clear the error state.
+ */
+/**
+ * The common API for loading and error states.
+ *
+ * @typedef {object} LoadingErrorStatus
+ * @property {Readonly<import("vue").Ref<boolean|undefined>>} loading - Whether the component is loading.
+ * @property {Readonly<import("vue").Ref<Error|null>>} error - The error that occurred.
+ * @property {Readonly<import("vue").Ref<boolean>>} 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;
+/**
+ * The common API for loading and error states.
+ */
+export type LoadingErrorStatus = {
+    /**
+     * - Whether the component is loading.
+     */
+    loading: Readonly<import("vue").Ref<boolean | undefined>>;
+    /**
+     * - The error that occurred.
+     */
+    error: Readonly<import("vue").Ref<Error | null>>;
+    /**
+     * - Whether an error has occurred.
+     */
+    errored: Readonly<import("vue").Ref<boolean>>;
+    /**
+     * - 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.
+ */
+export type LoadingError = LoadingErrorStatus & LoadingErrorMutations;
+//# sourceMappingURL=loadingError.d.ts.map

package/types/use/loadingError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadingError.d.ts","sourceRoot":"","sources":["../../use/loadingError.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;GAOG;AAEH;;;;GAIG;AAEH;;;;GAIG;AACH,mCAFa,YAAY,CA6BxB;;;;2BA5DY,MAAM,IAAI;;;;;;;;aAOT,QAAQ,CAAC,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,GAAC,SAAS,CAAC,CAAC;;;;WAC9C,QAAQ,CAAC,OAAO,KAAK,EAAE,GAAG,CAAC,KAAK,GAAC,IAAI,CAAC,CAAC;;;;aACvC,QAAQ,CAAC,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;;;;gBACpC,YAAY;;;;;;;;;gBAOZ,MAAM,IAAI;;;;kBACV,MAAM,IAAI;;;;cACV,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI;;;;;2BAMvB,kBAAkB,GAAG,qBAAqB"}

package/types/use/object.d.ts

@@ -0,0 +1,67 @@
+export function useObjects(objectArgs: {
+    [key: string]: ObjectManagerOptions;
+}): {
+    [key: string]: ObjectManager;
+};
+export function useObject({ props, functions }: ObjectManagerOptions): ObjectManager;
+/**
+ * Defines the raw reactive properties that can be passed to an object instance.
+ */
+export type ObjectManagerRawProps = (import("./objectInstance.js").ObjectInstanceRawProps & import("./objectSubscription.js").ObjectSubscriptionRawProps & import("./objectRelated.js").ObjectRelatedRawProps & import("./objectCalculated.js").ObjectCalculatedRawProps);
+/**
+ * Defines the reactive properties that can be passed to an object instance.
+ */
+export type ObjectManagerProps = import("vue").UnwrapNestedRefs<ObjectManagerRawProps>;
+/**
+ * Defines the non-reactive functions that can be passed to an object instance.
+ */
+export type ObjectManagerOptions = {
+    /**
+     * - The reactive properties to be passed to the object instance.
+     */
+    props: ObjectManagerProps;
+    /**
+     * - The non-reactive functions to be passed to the object instance.
+     */
+    functions: import("../config/objectCrud.js").ObjectCrudFunctions;
+};
+/**
+ * Defines the raw state of the object manager.
+ */
+export type ObjectManagerRawState = (import("./objectInstance.js").ObjectInstanceRawState & import("./objectSubscription.js").ObjectSubscriptionRawState & import("./objectRelated.js").ObjectRelatedRawState & import("./objectCalculated.js").ObjectCalculatedRawState);
+/**
+ * Defines the state of the object manager.
+ */
+export type ObjectManagerState = import("vue").UnwrapNestedRefs<ObjectManagerRawState>;
+/**
+ * Defines the managed object, containing the managed object instance, subscription, related objects, and calculated objects.
+ */
+export type ObjectManaged = {
+    objectInstance: import("./objectInstance.js").ObjectInstance;
+    objectSubscription: import("./objectSubscription.js").ObjectSubscription;
+    objectRelated: import("./objectRelated.js").ObjectRelated;
+    objectCalculated: import("./objectCalculated.js").ObjectCalculated;
+};
+/**
+ * Defines the functions provided by the object manager.
+ */
+export type ObjectManagerFunctions = (import("./objectInstance.js").ObjectInstanceFunctions & import("./objectSubscription.js").ObjectSubscriptionFunctions);
+/**
+ * Defines the properties available on an object manager.
+ */
+export type ObjectManagerProperties = {
+    /**
+     * - The managed object.
+     */
+    managed: ObjectManaged;
+    /**
+     * - The state of the managed object.
+     */
+    state: ObjectManagerState;
+    /**
+     * - The effect scope of the managed object.
+     */
+    effectScope: import("vue").EffectScope;
+};
+export type ObjectManager = ObjectManagerProperties & ObjectManagerFunctions;
+//# sourceMappingURL=object.d.ts.map

package/types/use/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../use/object.js"],"names":[],"mappings":"AA0GO,uCAPI;IACV,CAAO,GAAG,EAAE,MAAM,GAAG,oBAAoB,CAAC;CACvC,GACS;IACZ,CAAO,GAAG,EAAE,MAAM,GAAG,aAAa,CAAC;CAChC,CASH;AAoGM,gDAHI,oBAAoB,GAClB,aAAa,CA4EzB;;;;oCA7QY,CACZ,OAAa,qBAAqB,EAAE,sBAAsB,GAC1D,OAAa,yBAAyB,EAAE,0BAA0B,GAClE,OAAa,oBAAoB,EAAE,qBAAqB,GACxD,OAAa,uBAAuB,EAAE,wBAAwB,CAC3D;;;;iCAMS,OAAO,KAAK,EAAE,gBAAgB,CAAC,qBAAqB,CAAC;;;;;;;;WAOpD,kBAAkB;;;;eAClB,OAAO,yBAAyB,EAAE,mBAAmB;;;;;oCAMtD,CACZ,OAAa,qBAAqB,EAAE,sBAAsB,GAC1D,OAAa,yBAAyB,EAAE,0BAA0B,GAClE,OAAa,oBAAoB,EAAE,qBAAqB,GACxD,OAAa,uBAAuB,EAAE,wBAAwB,CAC3D;;;;iCAMS,OAAO,KAAK,EAAE,gBAAgB,CAAC,qBAAqB,CAAC;;;;4BAMrD;IACN,cAAc,EAAE,OAAO,qBAAqB,EAAE,cAAc,CAAC;IAC7D,kBAAkB,EAAE,OAAO,yBAAyB,EAAE,kBAAkB,CAAC;IACzE,aAAa,EAAE,OAAO,oBAAoB,EAAE,aAAa,CAAC;IAC1D,gBAAgB,EAAE,OAAO,uBAAuB,EAAE,gBAAgB,CAAC;CACtE;;;;qCAMS,CACZ,OAAa,qBAAqB,EAAE,uBAAuB,GACnD,OAAO,yBAAyB,EAAE,2BAA2B,CAClE;;;;;;;;aAYU,aAAa;;;;WACb,kBAAkB;;;;iBAClB,OAAO,KAAK,EAAE,WAAW;;4BAK1B,uBAAuB,GAAG,sBAAsB"}