@arrai-innovations/reactive-helpers 18.0.1 → 18.0.2

package/types/use/objectRelated.d.ts

@@ -0,0 +1,264 @@
+/**
+ * @typedef {object} ObjectRelatedProperties
+ * @property {ObjectRelatedState} state - The state of the object related instance.
+ * @property {ObjectRelatedParentState} parentState - The parent state.
+ * @property {import('./watchesRunning.js').WatchesRunning} watchesRunning - The watches running instance.
+ * @property {import('vue').EffectScope} effectScope - The effect scope.
+ *
+ */
+/**
+ * An instance of an object related reactive object.
+ *
+ * @typedef {ObjectRelatedProperties} ObjectRelated
+ */
+/**
+ * Non-parent state options for useObjectRelated.
+ *
+ * @typedef {object} ObjectRelatedRawProps
+ * @property {import('vue').Ref<ObjectRelatedRawRules>} relatedObjectRules - The rules for defining relationships for the managed object to other collections of objects.
+ */
+/**
+ * Options for useObjectRelated.
+ *
+ * @typedef {{
+ *     parentState: ObjectRelatedParentState,
+ * } & ObjectRelatedRawProps} ObjectRelatedOptions
+ */
+/**
+ *
+ * @param {{
+ *     [key: string]: ObjectRelatedOptions
+ * }} objectRelatedArgs - The options for the desired object related reactive objects.
+ * @returns {{
+ *     [key: string]: ObjectRelated
+ * }} - The object related instances, indexed by key.
+ */
+export function useObjectRelateds(objectRelatedArgs: {
+    [key: string]: ObjectRelatedOptions;
+}): {
+    [key: string]: ObjectRelated;
+};
+/**
+ * Creates an object related reactive object.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useObjectRelated, useObjectSubscription } from "@arrai-innovations/reactive-helpers";
+ * import { ref, reactive } from "vue";
+ *
+ * const someObjectsSource = reactive({
+ *     objects: {
+ *         '1': { id: 1, name: 'one', secondOrderId: 15 },
+ *         '2': { id: 2, name: 'two', secondOrderId: 10 },
+ *         '3': { id: 3, name: 'three', secondOrderId: 5 },
+ *     },
+ * });
+ * const someOtherObjectsSource = reactive({
+ *     objects: {
+ *         '5': { id: 5, name: 'five' },
+ *         '10': { id: 10, name: 'ten' },
+ *         '15': { id: 15, name: 'fifteen' },
+ *     },
+ * });
+ * const objectSubscriptionProps = reactive({
+ *     crudArgs: { app: 'foo', model: 'bar'},
+ *     retrieveArgs: {},
+ *     pk: '99',
+ *     pkKey: 'id',
+ *     intendToSubscribe: true,
+ *     intendToRetreive: true,
+ * });
+ * const objectSubscription = useObjectSubscription(objectSubscriptionProps);
+ * // objectSubscription.state.object like:
+ * // {
+ * //     id: '99',
+ * //     some_objects_id: '2',
+ * //     some_objects_list_ids: ['1','2','3'],
+ * // }
+ * const objectRelatedProps = reactive({
+ *     parentState: objectSubscription.state,
+ *     relatedObjectRules: {
+ *         firstOrder: {
+ *             pkKey: 'some_objects_id',
+ *             objects: someObjectsSource.objects,
+ *         },
+ *         some_objects_list_ids: {
+ *             // pkKey defaults to match rule name
+ *             objects: someObjectsSource.objects,
+ *             order: ['3','1','2'],
+ *         },
+ *         secondOrder: {
+ *             pkKey: 'relatedObject.secondOrderId',
+ *             objects: someOtherObjectsSource.objects,
+ *         },
+ *     },
+ * });
+ * const objectRelated = useObjectRelated(objectRelatedProps);
+ * </script>
+ * <template>
+ * <div>
+ *     <p>{{ objectRelated.state.relatedObject.firstOrder }}</p>
+ *     <!-- { id: 2, name: 'two', secondOrderId: 10 } -->
+ *
+ *     <p>{{ objectRelated.state.relatedObject.some_objects_list_ids }}</p>
+ *     <!-- [{ id: 3, name: 'three', secondOrderId: 5 }, { id: 1, name: 'one', secondOrderId: 15 }, { id: 2, name: 'two', secondOrderId: 10 }] -->
+ *
+ *     <p>{{ objectRelated.state.relatedObject.secondOrder }}</p>
+ *     <!-- { id: 10, name: 'ten' } -->
+ * </div>
+ * </template>
+ * ```
+ *
+ * @param {ObjectRelatedOptions} options - The options for the object related reactive object.
+ * @returns {ObjectRelated} - The object related reactive object.
+ */
+export function useObjectRelated({ parentState, relatedObjectRules }: ObjectRelatedOptions): ObjectRelated;
+/**
+ * Vue Composition API composable function for handling reactive relations to other objects.
+ *
+ * @module use/objectRelated.js
+ */
+/**
+ * The rule for defining relationships for the managed object to other collections of objects.
+ *
+ * @typedef {object} ObjectRelatedRule
+ * @property {string} pkKey - The key in the managed object that corresponds to the key in the related object.
+ * @property {import('./listInstance.js').ObjectsByPk} objects - The related objects, indexed by the key in the related object.
+ * @property {string[]} order - The order of the related objects, if the related objects are an array.
+ */
+/**
+ * The rules for defining relationships for the managed object to other collections of objects.
+ *
+ * @typedef {{
+ *     [rule: string]: ObjectRelatedRule,
+ * }} ObjectRelatedRawRules
+ */
+/**
+ *
+ *
+ * @typedef {object} ObjectRelatedRawState
+ * @property {ObjectRelatedRawRules} relatedObjectRules - The rules for defining relationships for the managed object to other collections of objects.
+ * @property {{
+ *     [rule: string]: import('vue').ComputedRef<any>,
+ * }} relatedObject - The related objects, indexed by the key in the related object.
+ * @property {boolean} relatedObjectWatchRunning - Whether the related object watch is running.
+ * @property {boolean} parentStateObjectWatchRunning - Whether the parent state object watch is running.
+ * @property {boolean} relatedRunning - Whether the related objects are loading.
+ * @property {boolean} running - Whether the related objects are loading or the parent state is loading.
+ */
+/**
+ *
+ *
+ * @typedef {(
+ *    import('./objectInstance.js').ObjectInstanceRawState &
+ *    Partial<import('./objectSubscription.js').ObjectSubscriptionRawState>
+ * )} ObjectRelatedParentRawState
+ */
+/**
+ *
+ *
+ * @typedef {import('vue').UnwrapNestedRefs<ObjectRelatedParentRawState>} ObjectRelatedParentState
+ */
+/**
+ *
+ *
+ * @typedef {import('vue').UnwrapNestedRefs<(
+ *     ObjectRelatedParentRawState &
+ *     ObjectRelatedRawState
+ * )>} ObjectRelatedState
+ */
+export const objectRelatedStateKeys: string[];
+export const objectRelatedFunctions: any[];
+export type ObjectRelatedProperties = {
+    /**
+     * - The state of the object related instance.
+     */
+    state: ObjectRelatedState;
+    /**
+     * - The parent state.
+     */
+    parentState: ObjectRelatedParentState;
+    /**
+     * - The watches running instance.
+     */
+    watchesRunning: import("./watchesRunning.js").WatchesRunning;
+    /**
+     * - The effect scope.
+     */
+    effectScope: import("vue").EffectScope;
+};
+/**
+ * An instance of an object related reactive object.
+ */
+export type ObjectRelated = ObjectRelatedProperties;
+/**
+ * Non-parent state options for useObjectRelated.
+ */
+export type ObjectRelatedRawProps = {
+    /**
+     * - The rules for defining relationships for the managed object to other collections of objects.
+     */
+    relatedObjectRules: import("vue").Ref<ObjectRelatedRawRules>;
+};
+/**
+ * Options for useObjectRelated.
+ */
+export type ObjectRelatedOptions = {
+    parentState: ObjectRelatedParentState;
+} & ObjectRelatedRawProps;
+/**
+ * The rule for defining relationships for the managed object to other collections of objects.
+ */
+export type ObjectRelatedRule = {
+    /**
+     * - The key in the managed object that corresponds to the key in the related object.
+     */
+    pkKey: string;
+    /**
+     * - The related objects, indexed by the key in the related object.
+     */
+    objects: import("./listInstance.js").ObjectsByPk;
+    /**
+     * - The order of the related objects, if the related objects are an array.
+     */
+    order: string[];
+};
+/**
+ * The rules for defining relationships for the managed object to other collections of objects.
+ */
+export type ObjectRelatedRawRules = {
+    [rule: string]: ObjectRelatedRule;
+};
+export type ObjectRelatedRawState = {
+    /**
+     * - The rules for defining relationships for the managed object to other collections of objects.
+     */
+    relatedObjectRules: ObjectRelatedRawRules;
+    /**
+     * - The related objects, indexed by the key in the related object.
+     */
+    relatedObject: {
+        [rule: string]: import("vue").ComputedRef<any>;
+    };
+    /**
+     * - Whether the related object watch is running.
+     */
+    relatedObjectWatchRunning: boolean;
+    /**
+     * - Whether the parent state object watch is running.
+     */
+    parentStateObjectWatchRunning: boolean;
+    /**
+     * - Whether the related objects are loading.
+     */
+    relatedRunning: boolean;
+    /**
+     * - Whether the related objects are loading or the parent state is loading.
+     */
+    running: boolean;
+};
+export type ObjectRelatedParentRawState = (import("./objectInstance.js").ObjectInstanceRawState & Partial<import("./objectSubscription.js").ObjectSubscriptionRawState>);
+export type ObjectRelatedParentState = import("vue").UnwrapNestedRefs<ObjectRelatedParentRawState>;
+export type ObjectRelatedState = import("vue").UnwrapNestedRefs<(ObjectRelatedParentRawState & ObjectRelatedRawState)>;
+//# sourceMappingURL=objectRelated.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"objectRelated.d.ts","sourceRoot":"","sources":["../../use/objectRelated.js"],"names":[],"mappings":"AAwFA;;;;;;;GAOG;AAIH;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;;;;GAMG;AAEH;;;;;;;;GAQG;AACH,qDAPW;IACV,CAAO,GAAG,EAAE,MAAM,GAAG,oBAAoB,CAAA;CACtC,GACS;IACZ,CAAO,GAAG,EAAE,MAAM,GAAG,aAAa,CAAA;CAC/B,CASH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,sEAHW,oBAAoB,GAClB,aAAa,CAqIzB;AAzUD;;;;GAIG;AAGH;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;;GAOG;AAEH;;;;GAIG;AAEH;;;;;;;GAOG;AAEH,8CAOE;AAEF,2CAAyC;;;;;WAI3B,kBAAkB;;;;iBAClB,wBAAwB;;;;oBACxB,OAAO,qBAAqB,EAAE,cAAc;;;;iBAC5C,OAAO,KAAK,EAAE,WAAW;;;;;4BAS1B,uBAAuB;;;;;;;;wBAOtB,OAAO,KAAK,EAAE,GAAG,CAAC,qBAAqB,CAAC;;;;;mCAMzC;IACN,WAAW,EAAE,wBAAwB,CAAC;CACzC,GAAG,qBAAqB;;;;;;;;WA3Fd,MAAM;;;;aACN,OAAO,mBAAmB,EAAE,WAAW;;;;WACvC,MAAM,EAAE;;;;;oCAMT;IACZ,CAAO,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAAC;CACrC;;;;;wBAOU,qBAAqB;;;;mBACrB;QACb,CAAO,IAAI,EAAE,MAAM,GAAG,OAAO,KAAK,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;KAClD;;;;+BACU,OAAO;;;;mCACP,OAAO;;;;oBACP,OAAO;;;;aACP,OAAO;;0CAMR,CACZ,OAAY,qBAAqB,EAAE,sBAAsB,GACpD,OAAO,CAAC,OAAO,yBAAyB,EAAE,0BAA0B,CAAC,CACvE;uCAMS,OAAO,KAAK,EAAE,gBAAgB,CAAC,2BAA2B,CAAC;iCAM3D,OAAO,KAAK,EAAE,gBAAgB,CAAC,CACrC,2BAA2B,GAC3B,qBAAqB,CACxB,CAAC"}

package/types/use/objectSubscription.d.ts

@@ -0,0 +1,249 @@
+/**
+ * The raw state of the object subscription.
+ *
+ * @typedef {object} ObjectSubscriptionRawState
+ * @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} intendToRetrieve - Whether the object intends to retrieve.
+ * @property {boolean} intendToSubscribe - Whether the object intends to subscribe.
+ * @property {boolean} subscribed - Whether the object is subscribed.
+ */
+/**
+ * The state of the object subscription, including both subscription and object instance states.
+ *
+ * @typedef {import('vue').UnwrapNestedRefs<
+ *     ObjectSubscriptionRawState &
+ *     import('./objectInstance.js').ObjectInstanceRawState
+ * >} ObjectSubscriptionState
+ */
+/**
+ * Functions available for object subscription management.
+ *
+ * @typedef {object} ObjectSubscriptionFunctions
+ * @property {({ retrieve }?: { retrieve?: boolean }) => boolean} subscribe - Subscribes to updates from an object, managing subscription state and
+ *  handling errors internally. Ensures that only one active subscription can exist at a time to prevent duplicate
+ *  calls. Returns a promise that resolves to true if the subscription was successful, and false if it failed.
+ * @property {() => boolean} unsubscribe - Unsubscribes from the object, resetting related state flags. Returns
+ *  true if the object was unsubscribed, and false if it was not subscribed.
+ * @property {(data: import('./objectInstance.js').CrudObject) => void} updateFromSubscription - Update the object from a subscription.
+ * @property {() => void} deleteFromSubscription - Delete the object from a subscription.
+ * @property {() => void} clearError - Clears any errors related to the subscription, and resets the loading state.
+ */
+/**
+ * Properties of the object subscription.
+ *
+ * @typedef {object} ObjectSubscriptionProperties
+ * @property {ObjectSubscriptionState} state - The object instance properties.
+ * @property {import('./objectInstance.js').ObjectInstance} objectInstance - The object instance.
+ * @property {import('./cancellableIntent.js').CancellableIntent} subscribeIntent - The subscribe intent.
+ * @property {import('./cancellableIntent.js').CancellableIntent} retrieveIntent - The retrieve intent.
+ * @property {import('vue').EffectScope} effectScope - The effect scope.
+ */
+/**
+ * The object subscription instance, combining state, properties, and functions.
+ *
+ * @typedef {ObjectSubscriptionProperties & ObjectSubscriptionFunctions} ObjectSubscription
+ */
+/**
+ * Raw props for the object subscription.
+ *
+ * @typedef {object} ObjectSubscriptionRawProps
+ * @property {boolean} [intendToRetrieve] - Whether the object intends to retrieve.
+ * @property {boolean} [intendToSubscribe] - Whether the object intends to subscribe.
+ */
+/**
+ * Options for initializing an object subscription, including reactive props and non-reactive functions.
+ *
+ * @typedef {object & import('./objectInstance.js').ObjectInstanceOptions} ObjectSubscriptionOptions
+ * @property {import('./objectInstance.js').ObjectInstance} [objectInstance] - An object instance to use instead of creating a new one.
+ * @property {import('vue').UnwrapNestedRefs<(
+ *     ObjectSubscriptionRawProps & import('./objectInstance.js').ObjectInstanceRawProps
+ * )>} props - The reactive args to be passed to useObjectInstance.
+ * @property {import('./objectInstance.js').ObjectInstanceFunctions} [functions] - The functions to be passed to useObjectInstance.
+ */
+/**
+ * Initializes multiple object subscriptions based on provided arguments.
+ *
+ * @param {{[key: string]: ObjectSubscriptionOptions}} subscriptionArgs - Arguments for initializing object subscriptions.
+ * @returns {{[key: string]: ObjectSubscription}} - An object containing the initialized object subscriptions.
+ */
+export function useObjectSubscriptions(subscriptionArgs: {
+    [key: string]: ObjectSubscriptionOptions;
+}): {
+    [key: string]: ObjectSubscription;
+};
+/**
+ * Initializes an object subscription to manage object state and reactivity, including subscription status and errors.
+ *
+ * @example
+ * ```
+ * <script setup>
+ * import { useObjectSubscription } from "@arrai-innovations/reactive-helpers";
+ * import { reactive, ref, toRef } from "vue";
+ *
+ * const pkKey = "id";
+ * const props = defineProps({
+ *     app: { type: String, required: true },
+ *     model: { type: String, required: true },
+ *     pk: { type: String, default: "" },
+ * });
+ *
+ * const objectSubscriptionProps = reactive({
+ *     crudArgs: {
+ *         app: toRef(props, "app"),
+ *         model: toRef(props, "model"),
+ *     },
+ *     pk: toRef(props, "pk"),
+ *     pkKey: pkKey,
+ *     retrieveArgs: {
+ *         fields: ['foo', 'bar'],
+ *     },
+ *     intendToRetrieve: false,
+ *     intendToSubscribe: false,
+ * });
+ * objectSubscriptionProps.intendToRetrieve = objectSubscriptionProps.intendToSubscribe = computed(()=> !!props.pk);
+ * const objectSubscription = useObjectSubscription(objectSubscriptionProps);
+ * </script>
+ * <template>
+ *     <div v-if="objectSubscription.state.loading">Loading...</div>
+ *     <div v-else-if="objectSubscription.state.errored">Error: {{ objectSubscription.state.error.message }}</div>
+ *     <div v-else-if="objectSubscription.state.object[pkKey]">Foo: {{ objectSubscription.state.object.foo }}</div>
+ *     <div v-else>Object not found.</div>
+ * </template>
+ * ```
+ *
+ * @param {ObjectSubscriptionOptions} options - Options for initializing the object subscription.
+ * @returns {ObjectSubscription} - An object containing the subscription state, properties, and functions.
+ */
+export function useObjectSubscription({ objectInstance, props, functions }: ObjectSubscriptionOptions): ObjectSubscription;
+/**
+ * A composition function for managing object subscriptions, including subscription status, errors, and reactivity.
+ *
+ * @module use/objectSubscription.js
+ */
+/**
+ * Custom error for handling issues related to object subscriptions.
+ */
+export class ObjectSubscriptionError extends Error {
+    /**
+     * Create a new ObjectSubscriptionError.
+     *
+     * @param {string} message - The error message.
+     * @param {string} code - The error code.
+     */
+    constructor(message: string, code: string);
+    code: string;
+}
+export const objectSubscriptionStateKeys: string[];
+export const objectSubscriptionFunctions: string[];
+/**
+ * The raw state of the object subscription.
+ */
+export type ObjectSubscriptionRawState = {
+    /**
+     * - 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>>;
+    /**
+     * - Whether the object intends to retrieve.
+     */
+    intendToRetrieve: boolean;
+    /**
+     * - Whether the object intends to subscribe.
+     */
+    intendToSubscribe: boolean;
+    /**
+     * - Whether the object is subscribed.
+     */
+    subscribed: boolean;
+};
+/**
+ * The state of the object subscription, including both subscription and object instance states.
+ */
+export type ObjectSubscriptionState = import("vue").UnwrapNestedRefs<ObjectSubscriptionRawState & import("./objectInstance.js").ObjectInstanceRawState>;
+/**
+ * Functions available for object subscription management.
+ */
+export type ObjectSubscriptionFunctions = {
+    /**
+     * - Subscribes to updates from an object, managing subscription state and
+     * handling errors internally. Ensures that only one active subscription can exist at a time to prevent duplicate
+     * calls. Returns a promise that resolves to true if the subscription was successful, and false if it failed.
+     */
+    subscribe: ({ retrieve }?: {
+        retrieve?: boolean;
+    }) => boolean;
+    /**
+     * - Unsubscribes from the object, resetting related state flags. Returns
+     * true if the object was unsubscribed, and false if it was not subscribed.
+     */
+    unsubscribe: () => boolean;
+    /**
+     * - Update the object from a subscription.
+     */
+    updateFromSubscription: (data: import("./objectInstance.js").CrudObject) => void;
+    /**
+     * - Delete the object from a subscription.
+     */
+    deleteFromSubscription: () => void;
+    /**
+     * - Clears any errors related to the subscription, and resets the loading state.
+     */
+    clearError: () => void;
+};
+/**
+ * Properties of the object subscription.
+ */
+export type ObjectSubscriptionProperties = {
+    /**
+     * - The object instance properties.
+     */
+    state: ObjectSubscriptionState;
+    /**
+     * - The object instance.
+     */
+    objectInstance: import("./objectInstance.js").ObjectInstance;
+    /**
+     * - The subscribe intent.
+     */
+    subscribeIntent: import("./cancellableIntent.js").CancellableIntent;
+    /**
+     * - The retrieve intent.
+     */
+    retrieveIntent: import("./cancellableIntent.js").CancellableIntent;
+    /**
+     * - The effect scope.
+     */
+    effectScope: import("vue").EffectScope;
+};
+/**
+ * The object subscription instance, combining state, properties, and functions.
+ */
+export type ObjectSubscription = ObjectSubscriptionProperties & ObjectSubscriptionFunctions;
+/**
+ * Raw props for the object subscription.
+ */
+export type ObjectSubscriptionRawProps = {
+    /**
+     * - Whether the object intends to retrieve.
+     */
+    intendToRetrieve?: boolean;
+    /**
+     * - Whether the object intends to subscribe.
+     */
+    intendToSubscribe?: boolean;
+};
+/**
+ * Options for initializing an object subscription, including reactive props and non-reactive functions.
+ */
+export type ObjectSubscriptionOptions = object & import("./objectInstance.js").ObjectInstanceOptions;
+//# sourceMappingURL=objectSubscription.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"objectSubscription.d.ts","sourceRoot":"","sources":["../../use/objectSubscription.js"],"names":[],"mappings":"AA+CA;;;;;;;;;;GAUG;AAEH;;;;;;;GAOG;AAGH;;;;;;;;;;;;GAYG;AAGH;;;;;;;;;GASG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;GASG;AAEH;;;;;GAKG;AACH,yDAHW;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,yBAAyB,CAAA;CAAC,GACxC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,CAAA;CAAC,CAS/C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,4EAHW,yBAAyB,GACvB,kBAAkB,CA6M9B;AAtXD;;;;GAIG;AAEH;;GAEG;AACH;IACI;;;;;OAKG;IACH,qBAHW,MAAM,QACN,MAAM,EAMhB;IADG,aAAgB;CAEvB;AAED,mDAOE;AAEF,mDAME;;;;;;;;yBAMY,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;;;;sBAClC,OAAO;;;;uBACP,OAAO;;;;gBACP,OAAO;;;;;sCAMR,OAAO,KAAK,EAAE,gBAAgB,CACpC,0BAA0B,GAChC,OAAa,qBAAqB,EAAE,sBAAsB,CACvD;;;;;;;;;;eAQU,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO;;;;;iBAGlD,MAAM,OAAO;;;;4BAEb,CAAC,IAAI,EAAE,OAAO,qBAAqB,EAAE,UAAU,KAAK,IAAI;;;;4BACxD,MAAM,IAAI;;;;gBACV,MAAM,IAAI;;;;;;;;;WAQV,uBAAuB;;;;oBACvB,OAAO,qBAAqB,EAAE,cAAc;;;;qBAC5C,OAAO,wBAAwB,EAAE,iBAAiB;;;;oBAClD,OAAO,wBAAwB,EAAE,iBAAiB;;;;iBAClD,OAAO,KAAK,EAAE,WAAW;;;;;iCAM1B,4BAA4B,GAAG,2BAA2B;;;;;;;;uBAOzD,OAAO;;;;wBACP,OAAO;;;;;wCAMR,MAAM,GAAG,OAAO,qBAAqB,EAAE,qBAAqB"}

package/types/use/paginatedListInstance.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @module use/paginatedListInstance.js
+ *
+ */
+/**
+ * @typedef {object} PagedListListanceOptions
+ * @property {boolean} keepOldPages - Whether to keep old pages.
+ */
+/**
+ * @typedef {object} PagedListInstanceState
+ * @property {number} totalRecords - The total records.
+ * @property {number} totalPages - The total pages.
+ * @property {number} perPage - The per page.
+ */
+/**
+ * @typedef {object} PagedListInstance
+ * @property {import('./listInstance.js').ListInstanceState & PagedListInstanceState} state - The state.
+ */
+/**
+ *
+ * @param {PagedListListanceOptions & import('./listInstance.js').ListInstanceOptions} options - The options.
+ * @returns {PagedListInstance} - The paged list instance.
+ */
+export function usePagedListInstance({ keepOldPages, ...useListInstanceArgs }: PagedListListanceOptions & import("./listInstance.js").ListInstanceOptions): PagedListInstance;
+export type PagedListListanceOptions = {
+    /**
+     * - Whether to keep old pages.
+     */
+    keepOldPages: boolean;
+};
+export type PagedListInstanceState = {
+    /**
+     * - The total records.
+     */
+    totalRecords: number;
+    /**
+     * - The total pages.
+     */
+    totalPages: number;
+    /**
+     * - The per page.
+     */
+    perPage: number;
+};
+export type PagedListInstance = {
+    /**
+     * - The state.
+     */
+    state: import("./listInstance.js").ListInstanceState & PagedListInstanceState;
+};
+//# sourceMappingURL=paginatedListInstance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paginatedListInstance.d.ts","sourceRoot":"","sources":["../../use/paginatedListInstance.js"],"names":[],"mappings":"AAEA;;;GAGG;AAEH;;;GAGG;AAEH;;;;;GAKG;AAEH;;;GAGG;AAEH;;;;GAIG;AACH,+EAHW,wBAAwB,GAAG,OAAO,mBAAmB,EAAE,mBAAmB,GACxE,iBAAiB,CA+C7B;;;;;kBAjEa,OAAO;;;;;;kBAKP,MAAM;;;;gBACN,MAAM;;;;aACN,MAAM;;;;;;WAKN,OAAO,mBAAmB,EAAE,iBAAiB,GAAG,sBAAsB"}

package/types/use/proxyLoadingError.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @typedef {(
+ *     import('./loadingError.js').LoadingErrorStatus[]
+ * )} WatchableLoadingErrorsRaw
+ */
+/**
+ * A watchable collection of loading errors.
+ *
+ * @typedef {(
+ *     import('vue').UnwrapNestedRefs<WatchableLoadingErrorsRaw> |
+ *     import('vue').Ref<WatchableLoadingErrorsRaw> |
+ *     WatchableLoadingErrorsRaw
+ * )} WatchableLoadingErrors
+ */
+/**
+ * The instance of useProxyLoadingError.
+ *
+ * @typedef {import('./loadingError.js').LoadingErrorStatus} ProxyLoadingError
+ */
+/**
+ * A composable function for managing aggregated loading and error states across multiple sources.
+ *
+ * @param {WatchableLoadingErrors} loadingErrors - A collection of loading error statuses to monitor and aggregate.
+ * @returns {ProxyLoadingError} An object containing aggregated reactive fields and actions for loading and error states.
+ */
+export function useProxyLoadingError(loadingErrors: WatchableLoadingErrors): ProxyLoadingError;
+export type WatchableLoadingErrorsRaw = (import("./loadingError.js").LoadingErrorStatus[]);
+/**
+ * A watchable collection of loading errors.
+ */
+export type WatchableLoadingErrors = (import("vue").UnwrapNestedRefs<WatchableLoadingErrorsRaw> | import("vue").Ref<WatchableLoadingErrorsRaw> | WatchableLoadingErrorsRaw);
+/**
+ * The instance of useProxyLoadingError.
+ */
+export type ProxyLoadingError = import("./loadingError.js").LoadingErrorStatus;
+//# sourceMappingURL=proxyLoadingError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proxyLoadingError.d.ts","sourceRoot":"","sources":["../../use/proxyLoadingError.js"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;;;GAIG;AAEH;;;;;GAKG;AACH,oDAHW,sBAAsB,GACpB,iBAAiB,CA6B7B;wCAtDY,CACZ,OAAa,mBAAmB,EAAE,kBAAkB,EAAE,CACnD;;;;qCAMS,CACZ,OAAa,KAAK,EAAE,gBAAgB,CAAC,yBAAyB,CAAC,GAC/D,OAAa,KAAK,EAAE,GAAG,CAAC,yBAAyB,CAAC,GAC5C,yBAAyB,CAC5B;;;;gCAMS,OAAO,mBAAmB,EAAE,kBAAkB"}