@arrai-innovations/reactive-helpers 18.0.2 → 19.0.0

package/types/use/objectInstance.d.ts

@@ -70,14 +70,20 @@ export function useObjectInstance({ props, functions }: ObjectInstanceOptions):
 /**
  * The object being managed by the instance. Empty object is the default.
  *
- * @typedef {{pkKey: string, [key: string]: any}|{}} CrudObject
+ * @typedef {{pkKey: string, [key: string]: any}} ExistingCrudObject
+ */
+/**
+ * @typedef {{[key: string]: any}} NewCrudObject
+ */
+/**
+ * @typedef {ExistingCrudObject|NewCrudObject} CrudObject
  */
 /**
  * Arguments to be passed to the object instance.
  *
  * @typedef {object} ObjectInstanceOptions
  * @property {import('vue').UnwrapNestedRefs<ObjectInstanceRawProps>} props - The reactive configuration object.
- * @property {import('../config/objectCrud.js').ObjectCrudFunctions} functions - An object of custom crud functions to use instead of the defaults.
+ * @property {import('../config/objectCrud.js').ObjectCrudFunctions} [functions] - An object of custom crud functions to use instead of the defaults.
  */
 /**
  * Reactive arguments to be passed to the object instance.
@@ -88,35 +94,45 @@ export function useObjectInstance({ props, functions }: ObjectInstanceOptions):
  * @property {object} retrieveArgs - The arguments to be passed to the retrieve function.
  * @property {import('../config/objectCrud.js').ObjectCrudArgs} crudArgs - The arguments to be passed to the crud functions.
  */
+/**
+ * @typedef {object} ObjectInstanceRawStateCrud
+ * @property {import('vue').Reactive<import('../config/objectCrud.js').ObjectCrudArgsArgs|{}>} args - The arguments to be passed to the crud functions.
+ * @property {import('../config/objectCrud.js').CrudCreateFn} create - The create function.
+ * @property {import('../config/objectCrud.js').CrudRetrieveFn} retrieve - The retrieve function.
+ * @property {import('../config/objectCrud.js').CrudUpdateFn} update - The update function.
+ * @property {import('../config/objectCrud.js').CrudPatchFn} patch - The patch function.
+ * @property {import('../config/objectCrud.js').CrudDeleteFn} delete - The delete function.
+ * @property {import('../config/objectCrud.js').CrudObjectSubscribeFn} subscribe - The subscribe function.
+ */
 /**
  * The raw state of the object instance.
  *
  * @typedef {object} ObjectInstanceRawState
- * @property {import('../config/objectCrud.js').ObjectCrudArgs} crud - The crud functions.
- * @property {string} pk - The pk of the object.
- * @property {string} pkKey - The pk key of the object.
- * @property {object} retrieveArgs - The arguments to be passed to the retrieve function.
- * @property {CrudObject} object - The object.
+ * @property {import('vue').Reactive<ObjectInstanceRawStateCrud>} crud - The crud functions.
+ * @property {import('vue').Ref<string|undefined>} pk - The pk of the object.
+ * @property {import('vue').Ref<string|undefined>} pkKey - The pk key of the object.
+ * @property {import('vue').Ref<{[key:string]: any}>} retrieveArgs - The arguments to be passed to the retrieve function.
+ * @property {import('vue').Reactive<CrudObject>} object - The object.
  * @property {Readonly<import('vue').Ref<boolean>>} loading - Whether the object is loading.
  * @property {Readonly<import('vue').Ref<boolean>>} errored - Whether the object errored.
  * @property {Readonly<import('vue').Ref<Error|null>>} error - The error.
- * @property {Readonly<import('vue').Ref<boolean>>} deleted - Whether the object is deleted.
+ * @property {boolean} deleted - Whether the object is deleted.
  */
 /**
  * Manages a reactive state of an object including its CRUD status, loading states, and any operational errors.
  * Reactivity ensures that any changes in state immediately reflect in the UI components that depend on this state.
  *
- * @typedef {import('vue').UnwrapNestedRefs<ObjectInstanceRawState>} ObjectInstanceState
+ * @typedef {import('vue').Reactive<ObjectInstanceRawState>} ObjectInstanceState
  */
 /**
  * The functions available on the object instance.
  *
  * @typedef {object} ObjectInstanceFunctions
- * @property {(args: { object: object }) => Promise<boolean>} create - Called to turn the current object into a new object on the server.
- * @property {() => Promise<boolean>} retrieve - Called to retrieve the current object by pk from the server.
- * @property {(args: { object: CrudObject }) => Promise<boolean>} update - Called to update the current object on the server.
- * @property {() => Promise<boolean>} delete - Called to delete the current object on the server.
- * @property {(args: { partialObject: CrudObject }) => Promise<boolean>} patch - Called to patch the current object on the server.
+ * @property {(args: { object: object }) => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean>} create - Called to turn the current object into a new object on the server.
+ * @property {() => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean>} retrieve - Called to retrieve the current object by pk from the server.
+ * @property {(args: { object: ExistingCrudObject }) => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean>} update - Called to update the current object on the server.
+ * @property {() => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean>} delete - Called to delete the current object on the server.
+ * @property {(args: { partialObject: ExistingCrudObject }) => import('../utils/cancellablePromise.js').MaybeCancellablePromise<boolean>} patch - Called to patch the current object on the server.
  * @property {import('./loadingError.js').ClearErrorFn} clearError - Called to clear the error state.
  * @property {() => void} clear - Called to clear the object state.
  */
@@ -150,10 +166,14 @@ export const objectInstanceFunctions: string[];
 /**
  * The object being managed by the instance. Empty object is the default.
  */
-export type CrudObject = {
+export type ExistingCrudObject = {
     pkKey: string;
     [key: string]: any;
-} | {};
+};
+export type NewCrudObject = {
+    [key: string]: any;
+};
+export type CrudObject = ExistingCrudObject | NewCrudObject;
 /**
  * Arguments to be passed to the object instance.
  */
@@ -165,7 +185,7 @@ export type ObjectInstanceOptions = {
     /**
      * - An object of custom crud functions to use instead of the defaults.
      */
-    functions: import("../config/objectCrud.js").ObjectCrudFunctions;
+    functions?: import("../config/objectCrud.js").ObjectCrudFunctions;
 };
 /**
  * Reactive arguments to be passed to the object instance.
@@ -188,6 +208,36 @@ export type ObjectInstanceRawProps = {
      */
     crudArgs: import("../config/objectCrud.js").ObjectCrudArgs;
 };
+export type ObjectInstanceRawStateCrud = {
+    /**
+     * - The arguments to be passed to the crud functions.
+     */
+    args: import("vue").Reactive<import("../config/objectCrud.js").ObjectCrudArgsArgs | {}>;
+    /**
+     * - The create function.
+     */
+    create: import("../config/objectCrud.js").CrudCreateFn;
+    /**
+     * - The retrieve function.
+     */
+    retrieve: import("../config/objectCrud.js").CrudRetrieveFn;
+    /**
+     * - The update function.
+     */
+    update: import("../config/objectCrud.js").CrudUpdateFn;
+    /**
+     * - The patch function.
+     */
+    patch: import("../config/objectCrud.js").CrudPatchFn;
+    /**
+     * - The delete function.
+     */
+    delete: import("../config/objectCrud.js").CrudDeleteFn;
+    /**
+     * - The subscribe function.
+     */
+    subscribe: import("../config/objectCrud.js").CrudObjectSubscribeFn;
+};
 /**
  * The raw state of the object instance.
  */
@@ -195,23 +245,25 @@ export type ObjectInstanceRawState = {
     /**
      * - The crud functions.
      */
-    crud: import("../config/objectCrud.js").ObjectCrudArgs;
+    crud: import("vue").Reactive<ObjectInstanceRawStateCrud>;
     /**
      * - The pk of the object.
      */
-    pk: string;
+    pk: import("vue").Ref<string | undefined>;
     /**
      * - The pk key of the object.
      */
-    pkKey: string;
+    pkKey: import("vue").Ref<string | undefined>;
     /**
      * - The arguments to be passed to the retrieve function.
      */
-    retrieveArgs: object;
+    retrieveArgs: import("vue").Ref<{
+        [key: string]: any;
+    }>;
     /**
      * - The object.
      */
-    object: CrudObject;
+    object: import("vue").Reactive<CrudObject>;
     /**
      * - Whether the object is loading.
      */
@@ -227,13 +279,13 @@ export type ObjectInstanceRawState = {
     /**
      * - Whether the object is deleted.
      */
-    deleted: Readonly<import("vue").Ref<boolean>>;
+    deleted: boolean;
 };
 /**
  * Manages a reactive state of an object including its CRUD status, loading states, and any operational errors.
  * Reactivity ensures that any changes in state immediately reflect in the UI components that depend on this state.
  */
-export type ObjectInstanceState = import("vue").UnwrapNestedRefs<ObjectInstanceRawState>;
+export type ObjectInstanceState = import("vue").Reactive<ObjectInstanceRawState>;
 /**
  * The functions available on the object instance.
  */
@@ -243,27 +295,27 @@ export type ObjectInstanceFunctions = {
      */
     create: (args: {
         object: object;
-    }) => Promise<boolean>;
+    }) => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean>;
     /**
      * - Called to retrieve the current object by pk from the server.
      */
-    retrieve: () => Promise<boolean>;
+    retrieve: () => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean>;
     /**
      * - Called to update the current object on the server.
      */
     update: (args: {
-        object: CrudObject;
-    }) => Promise<boolean>;
+        object: ExistingCrudObject;
+    }) => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean>;
     /**
      * - Called to delete the current object on the server.
      */
-    delete: () => Promise<boolean>;
+    delete: () => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean>;
     /**
      * - Called to patch the current object on the server.
      */
     patch: (args: {
-        partialObject: CrudObject;
-    }) => Promise<boolean>;
+        partialObject: ExistingCrudObject;
+    }) => import("../utils/cancellablePromise.js").MaybeCancellablePromise<boolean>;
     /**
      * - Called to clear the error state.
      */

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

@@ -1 +1 @@
-{"version":3,"file":"objectInstance.d.ts","sourceRoot":"","sources":["../../use/objectInstance.js"],"names":[],"mappings":"AAmHA;;;;;GAKG;AACH,iDAHW;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB,CAAA;CAAC,GACpC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAAA;CAAC,CAS3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wDAHW,qBAAqB,GACnB,cAAc,CAkM1B;AAjXD;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;GAaG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;GAGG;AACH;IACI;;;;;OAKG;IACH,qBAHW,MAAM,QACN,MAAM,EAMhB;IADG,aAAgB;CAEvB;AAED,+CAUE;AAEF,+CAAkH;;;;yBAnGrG;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,GAAC,EAAE;;;;;;;;WAOrC,OAAO,KAAK,EAAE,gBAAgB,CAAC,sBAAsB,CAAC;;;;eACtD,OAAO,yBAAyB,EAAE,mBAAmB;;;;;;;;;SAOrD,MAAM;;;;WACN,MAAM;;;;kBACN,MAAM;;;;cACN,OAAO,yBAAyB,EAAE,cAAc;;;;;;;;;UAOhD,OAAO,yBAAyB,EAAE,cAAc;;;;QAChD,MAAM;;;;WACN,MAAM;;;;kBACN,MAAM;;;;YACN,UAAU;;;;aACV,QAAQ,CAAC,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;;;;aACpC,QAAQ,CAAC,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;;;;WACpC,QAAQ,CAAC,OAAO,KAAK,EAAE,GAAG,CAAC,KAAK,GAAC,IAAI,CAAC,CAAC;;;;aACvC,QAAQ,CAAC,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;;;;;;kCAOrC,OAAO,KAAK,EAAE,gBAAgB,CAAC,sBAAsB,CAAC;;;;;;;;YAOrD,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC;;;;cAC9C,MAAM,OAAO,CAAC,OAAO,CAAC;;;;YACtB,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,UAAU,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC;;;;YAClD,MAAM,OAAO,CAAC,OAAO,CAAC;;;;WACtB,CAAC,IAAI,EAAE;QAAE,aAAa,EAAE,UAAU,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC;;;;gBACzD,OAAO,mBAAmB,EAAE,YAAY;;;;WACxC,MAAM,IAAI;;;;;;;;;WAOV,mBAAmB;;;;;6BAMpB,uBAAuB,GAAG,wBAAwB"}
+{"version":3,"file":"objectInstance.d.ts","sourceRoot":"","sources":["../../use/objectInstance.js"],"names":[],"mappings":"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"}

package/types/use/objectSubscription.d.ts

@@ -2,17 +2,17 @@
  * 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.
+ * @property {import('./loadingError.js').LoadingReadonlyRef} subscriptionLoading - Whether the subscription is loading.
+ * @property {import('./loadingError.js').ErroredReadonlyRef} subscriptionErrored - Whether the subscription has errored.
+ * @property {import('./loadingError.js').ErrorReadonlyRef} subscriptionError - The error that occurred.
+ * @property {import('vue').Ref<boolean>} intendToRetrieve - Whether the object intends to retrieve.
+ * @property {import('vue').Ref<boolean>} intendToSubscribe - Whether the object intends to subscribe.
+ * @property {import('vue').Ref<boolean|undefined>} subscribed - Whether the object is subscribed.
  */
 /**
  * The state of the object subscription, including both subscription and object instance states.
  *
- * @typedef {import('vue').UnwrapNestedRefs<
+ * @typedef {import('vue').Reactive<
  *     ObjectSubscriptionRawState &
  *     import('./objectInstance.js').ObjectInstanceRawState
  * >} ObjectSubscriptionState
@@ -21,12 +21,15 @@
  * 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 {(
+ *     (options?: { 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 {(data: import('./objectInstance.js').ExistingCrudObject) => 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.
  */
@@ -49,8 +52,8 @@
  * 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.
+ * @property {boolean|undefined} intendToRetrieve - Whether the object intends to retrieve.
+ * @property {boolean|undefined} intendToSubscribe - Whether the object intends to subscribe.
  */
 /**
  * Options for initializing an object subscription, including reactive props and non-reactive functions.
@@ -144,53 +147,54 @@ export type ObjectSubscriptionRawState = {
     /**
      * - Whether the subscription is loading.
      */
-    subscriptionLoading: Readonly<import("vue").Ref<boolean>>;
+    subscriptionLoading: import("./loadingError.js").LoadingReadonlyRef;
     /**
      * - Whether the subscription has errored.
      */
-    subscriptionErrored: Readonly<import("vue").Ref<boolean>>;
+    subscriptionErrored: import("./loadingError.js").ErroredReadonlyRef;
     /**
      * - The error that occurred.
      */
-    subscriptionError: Readonly<import("vue").Ref<Error>>;
+    subscriptionError: import("./loadingError.js").ErrorReadonlyRef;
     /**
      * - Whether the object intends to retrieve.
      */
-    intendToRetrieve: boolean;
+    intendToRetrieve: import("vue").Ref<boolean>;
     /**
      * - Whether the object intends to subscribe.
      */
-    intendToSubscribe: boolean;
+    intendToSubscribe: import("vue").Ref<boolean>;
     /**
      * - Whether the object is subscribed.
      */
-    subscribed: boolean;
+    subscribed: import("vue").Ref<boolean | undefined>;
 };
 /**
  * The state of the object subscription, including both subscription and object instance states.
  */
-export type ObjectSubscriptionState = import("vue").UnwrapNestedRefs<ObjectSubscriptionRawState & import("./objectInstance.js").ObjectInstanceRawState>;
+export type ObjectSubscriptionState = import("vue").Reactive<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.
+     * - 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 }?: {
+    subscribe: ((options?: {
         retrieve?: boolean;
-    }) => 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.
+     * - Update the
+     * object from a subscription.
      */
-    updateFromSubscription: (data: import("./objectInstance.js").CrudObject) => void;
+    updateFromSubscription: (data: import("./objectInstance.js").ExistingCrudObject) => void;
     /**
      * - Delete the object from a subscription.
      */
@@ -236,11 +240,11 @@ export type ObjectSubscriptionRawProps = {
     /**
      * - Whether the object intends to retrieve.
      */
-    intendToRetrieve?: boolean;
+    intendToRetrieve: boolean | undefined;
     /**
      * - Whether the object intends to subscribe.
      */
-    intendToSubscribe?: boolean;
+    intendToSubscribe: boolean | undefined;
 };
 /**
  * Options for initializing an object subscription, including reactive props and non-reactive functions.

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

@@ -1 +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"}
+{"version":3,"file":"objectSubscription.d.ts","sourceRoot":"","sources":["../../use/objectSubscription.js"],"names":[],"mappings":"AAgDA;;;;;;;;;;GAUG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;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,CA0M9B;AApXD;;;;GAIG;AAEH;;GAEG;AACH;IACI;;;;;OAKG;IACH,qBAHW,MAAM,QACN,MAAM,EAMhB;IADG,aAAgB;CAEvB;AAED,mDAOE;AAEF,mDAME;;;;;;;;yBAMY,OAAO,mBAAmB,EAAE,kBAAkB;;;;yBAC9C,OAAO,mBAAmB,EAAE,kBAAkB;;;;uBAC9C,OAAO,mBAAmB,EAAE,gBAAgB;;;;sBAC5C,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC;;;;uBAC1B,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC;;;;gBAC1B,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,GAAC,SAAS,CAAC;;;;;sCAMrC,OAAO,KAAK,EAAE,QAAQ,CAC5B,0BAA0B,GAChC,OAAa,qBAAqB,EAAE,sBAAsB,CACvD;;;;;;;;;;eAOU,CACb,CAAO,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAChD;;;;;iBAGU,MAAM,OAAO;;;;;4BAEb,CAAC,IAAI,EAAE,OAAO,qBAAqB,EAAE,kBAAkB,KAAK,IAAI;;;;4BAEhE,MAAM,IAAI;;;;gBACV,MAAM,IAAI;;;;;;;;;WAOV,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;;;;;;;;sBAOzD,OAAO,GAAC,SAAS;;;;uBACjB,OAAO,GAAC,SAAS;;;;;wCAMlB,MAAM,GAAG,OAAO,qBAAqB,EAAE,qBAAqB"}

package/types/use/proxyLoadingError.d.ts

@@ -1,36 +1,21 @@
-/**
- * @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
+ *     import('vue').UnwrapNestedRefs<import('./loadingError.js').LoadingErrorStatus> |
+ *     import('vue').Ref<import('./loadingError.js').LoadingErrorStatus> |
+ *     import('./loadingError.js').LoadingErrorStatus
+ * )} WatchableLoadingError
  */
 /**
  * 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.
+ * @param {WatchableLoadingError[]} loadingErrors - A collection of loading error statuses to monitor and aggregate.
+ * @returns {import('./loadingError.js').LoadingErrorStatus} 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[]);
+export function useProxyLoadingError(loadingErrors: WatchableLoadingError[]): 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;
+export type WatchableLoadingError = (import("vue").UnwrapNestedRefs<import("./loadingError.js").LoadingErrorStatus> | import("vue").Ref<import("./loadingError.js").LoadingErrorStatus> | import("./loadingError.js").LoadingErrorStatus);
 //# sourceMappingURL=proxyLoadingError.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"proxyLoadingError.d.ts","sourceRoot":"","sources":["../../use/proxyLoadingError.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AAEH;;;;;GAKG;AACH,oDAHW,qBAAqB,EAAE,GACrB,OAAO,mBAAmB,EAAE,kBAAkB,CA2B1D;;;;oCAtCY,CACZ,OAAa,KAAK,EAAE,gBAAgB,CAAC,OAAO,mBAAmB,EAAE,kBAAkB,CAAC,GACpF,OAAa,KAAK,EAAE,GAAG,CAAC,OAAO,mBAAmB,EAAE,kBAAkB,CAAC,GACvE,OAAa,mBAAmB,EAAE,kBAAkB,CACjD"}

package/types/utils/cancellableFetch.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A wrapper around fetch that adds cancellation via AbortController and returns a CancellablePromise.
+ *
+ * @template T
+ * @param {RequestInfo} input - The URL or Request object to fetch.
+ * @param {RequestInit} init - The options for the fetch request.
+ * @param {(response: Response) => Promise<T>} transform - A function to transform the response.
+ * @returns {CancellablePromise<T>} A cancellable promise that resolves to the transformed response.
+ */
+export function cancellableFetch<T>(input: RequestInfo, init: RequestInit, transform: (response: Response) => Promise<T>): CancellablePromise<T>;
+import { CancellablePromise } from "./cancellablePromise.js";
+//# sourceMappingURL=cancellableFetch.d.ts.map

package/types/utils/cancellableFetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cancellableFetch.d.ts","sourceRoot":"","sources":["../../utils/cancellableFetch.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,iCANa,CAAC,SACH,WAAW,QACX,WAAW,aACX,CAAC,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,GAChC,kBAAkB,CAAC,CAAC,CAAC,CAYjC;mCArBkC,yBAAyB"}

package/types/utils/cancellablePromise.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Wraps a promise and optionally adds a cancel method if provided.
+ *
+ * @template T
+ * @param {Promise<T>} inner - The inner promise to wrap.
+ * @param {(() => Promise<void> | void)=} cancel - Optional cancel function.
+ * @returns {MaybeCancellablePromise<T>} The wrapped promise with an optional cancel method.
+ */
+export function wrapMaybeCancellable<T>(inner: Promise<T>, cancel?: (() => Promise<void> | void) | undefined): MaybeCancellablePromise<T>;
+export function CancellablePromise<T>(promise: Promise<T>, cancel: () => (Promise<void> | void)): CancellablePromise<T>;
+/**
+ * A Promise that can be cancelled.
+ */
+export type CancellablePromise<T> = Promise<T> & {
+    cancel: (reason?: any) => Promise<void> | void;
+};
+export namespace CancellablePromise {
+    /**
+     * Creates a rejected 'cancellable' promise.
+     *
+     * @param {any} reason - The reason for the rejection.
+     * @returns {MaybeCancellablePromise<never>} A rejected 'cancellable' promise.
+     */
+    function reject(reason: any): MaybeCancellablePromise<never>;
+    /**
+     * Creates a resolved 'cancellable' promise.
+     *
+     * @template T
+     * @param {T} value - The value to resolve the promise with.
+     * @returns {MaybeCancellablePromise<T>} A resolved 'cancellable' promise.
+     */
+    function resolve<T_1>(value: T_1): MaybeCancellablePromise<T_1>;
+}
+/**
+ * A possibly cancellable promise.
+ */
+export type MaybeCancellablePromise<T> = Promise<T> & {
+    cancel?: (reason?: any) => Promise<void> | void;
+};
+//# sourceMappingURL=cancellablePromise.d.ts.map

package/types/utils/cancellablePromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cancellablePromise.d.ts","sourceRoot":"","sources":["../../utils/cancellablePromise.js"],"names":[],"mappings":"AAiDA;;;;;;;GAOG;AACH,qCALa,CAAC,SACH,OAAO,CAAC,CAAC,CAAC,WACV,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,YAAC,GAC3B,uBAAuB,CAAC,CAAC,CAAC,CActC;AA/CM,mCALM,CAAC,WACH,OAAO,CAAC,CAAC,CAAC,UACV,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,GAAC,IAAI,CAAC,GACxB,kBAAkB,CAAC,CAAC,CAAC,CAMjC;;;;+BAvBY,CAAC,IACD,OAAO,CAAC,CAAC,CAAC,GAAG;IAAE,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CAAE;;IAwB5E;;;;;OAKG;IACH,wBAHW,GAAG,GACD,uBAAuB,CAAC,KAAK,CAAC,CAI1C;IAED;;;;;;OAMG;IACH,6BAHW,GAAC,GACC,uBAAuB,CAAC,GAAC,CAAC,CAItC;;;;;oCArCY,CAAC,IACD,OAAO,CAAC,CAAC,CAAC,GAAG;IAAE,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CAAE"}

package/types/utils/deepUnref.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Recursively unwraps refs from a nested object, array, or primitive.
+ *
+ * @template T
+ * @typedef {T extends import('vue').Ref<infer U>
+ *   ? DeepUnwrap<U>
+ *   : T extends Array<infer V>
+ *     ? Array<DeepUnwrap<V>>
+ *     : T extends object
+ *       ? { [K in keyof T]: DeepUnwrap<T[K]> }
+ *       : T
+ * } DeepUnwrap
+ */
+/**
+ * Safe, recursively-typed deep unref.
+ *
+ * @template T
+ * @param {T} val - The value to deeply unwrap.
+ * @returns {DeepUnwrap<T>} - The deeply unwrapped value.
+ */
+export const deepUnref: any;
+/**
+ * Recursively unwraps refs from a nested object, array, or primitive.
+ */
+export type DeepUnwrap<T_1> = T_1 extends import("vue").Ref<infer U> ? DeepUnwrap<U> : T_1 extends Array<infer V> ? Array<DeepUnwrap<V>> : T_1 extends object ? { [K in keyof T_1]: DeepUnwrap<T_1[K]>; } : T_1;
+//# sourceMappingURL=deepUnref.d.ts.map

package/types/utils/deepUnref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepUnref.d.ts","sourceRoot":"","sources":["../../utils/deepUnref.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AAIH;;;;;;GAMG;AACH,4BAAoC;;;;8BAnBvB,GAAC,SAAS,OAAO,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,GAC1C,UAAU,CAAC,CAAC,CAAC,GACb,GAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GACtB,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GACpB,GAAC,SAAS,MAAM,GACd,GAAG,CAAC,IAAI,MAAM,GAAC,GAAG,UAAU,CAAC,GAAC,CAAC,CAAC,CAAC,CAAC,GAAE,GACpC,GAAC"}

package/types/utils/refIfReactive.d.ts

@@ -0,0 +1,2 @@
+export function refIfReactive<T, K extends keyof T>(source: (T & object) | undefined | null, property: K, defaultValue?: T[K]): import("vue").Ref<T[K]> | T[K] | undefined;
+//# sourceMappingURL=refIfReactive.d.ts.map

package/types/utils/refIfReactive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refIfReactive.d.ts","sourceRoot":"","sources":["../../utils/refIfReactive.js"],"names":[],"mappings":"AAYO,8BAPM,CAAC,EACS,CAAC,SAAX,MAAO,CAAE,UACX,CAAA,CAAC,GAAG,MAAM,IAAG,SAAS,GAAG,IAAI,YAC7B,CAAC,iBACD,CAAC,CAAC,CAAC,CAAC,GACF,OAAO,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAOtD"}

package/types/utils/unwrapNested.d.ts

@@ -0,0 +1,2 @@
+export function unwrapNested<T>(arg: T): import("vue").UnwrapRef<T>;
+//# sourceMappingURL=unwrapNested.d.ts.map

package/types/utils/unwrapNested.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrapNested.d.ts","sourceRoot":"","sources":["../../utils/unwrapNested.js"],"names":[],"mappings":"AASO,6BAJM,CAAC,OACH,CAAC,GACC,OAAO,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,CAiBtC"}

package/use/cancellableIntent.js

@@ -2,19 +2,13 @@ import identity from "lodash-es/identity.js";
 import isEmpty from "lodash-es/isEmpty.js";
 import isEqual from "lodash-es/isEqual.js";
 import { computed, effectScope, nextTick, onScopeDispose, reactive, readonly, watch } from "vue";
-import { deepUnref } from "vue-deepunref";
+import { deepUnref } from "../utils/deepUnref.js";
 import { tryOnActivated, tryOnDeactivated } from "../utils/keepAliveTry.js";
 
 /**
  * @module use/cancellableIntent.js - A composable function for handling cancellable intents.
  */
 
-/**
- * A Promise that can be cancelled.
- *
- * @typedef {Promise<any> & { cancel: () => Promise<void>|void }} CancellablePromise
- */
-
 /**
  * @typedef {import("vue").UnwrapNestedRefs<object>} CancellableIntentState - The state of the cancellable intent.
  * @property {number} activeCount - The number of active intents.
@@ -28,7 +22,7 @@ import { tryOnActivated, tryOnDeactivated } from "../utils/keepAliveTry.js";
 
 /**
  * @typedef {object} CancellableIntentOptions - The options for the cancellable intent.
- * @property {() => CancellablePromise} awaitableWithCancel - The function that returns a promise that can be cancelled.
+ * @property {() => import('../utils/cancellablePromise.js').MaybeCancellablePromise<void>} awaitableWithCancel - The function that returns a promise that can be cancelled.
  * @property {import("vue").UnwrapNestedRefs<object>} [watchArguments={}] - The reactive object to watch for changes.
  * @property {import("vue").UnwrapNestedRefs<object>} [guardArguments={}] - The reactive object to watch for truthiness before running the intent.
  * @property {boolean} [clearActiveOnResolved=true] - Whether to clear the active state when the promise resolves.
@@ -112,9 +106,9 @@ export function useCancellableIntent({
         es.stop();
     }
 
-    async function cancel() {
+    async function cancel(reason) {
         if (cancelFunction) {
-            return cancelFunction()
+            return cancelFunction(reason)
                 .catch(console.error)
                 .finally(() => {
                     if (!state.clearActiveOnResolved) {
@@ -145,7 +139,7 @@ export function useCancellableIntent({
         // we don't want to await this, because we want to be able to cancel it
         awaitablePromise
             .catch(async (err) => {
-                await cancel();
+                await cancel("Error in awaitableWithCancel");
                 console.error(err);
                 state.errored = true;
                 state.error = err;
@@ -174,7 +168,7 @@ export function useCancellableIntent({
             if (isEqual(newWatchValues, previousWatchValues)) {
                 return;
             }
-            await cancel(); // this can take time so guards and watches can change!
+            await cancel("Intent watch cancelled"); // this can take time so guards and watches can change!
             newWatchValues = deepUnref(Object.values(watchArguments));
             if (isEqual(newWatchValues, previousWatchValues)) {
                 return;
@@ -212,7 +206,8 @@ export function useCancellableIntent({
 
     const cleanup = () => {
         // cancel the intent when the component is deactivated
-        cancel();
+        // noinspection JSIgnoredPromiseFromCall
+        cancel("Component deactivated");
         if (state.clearActiveOnResolved) {
             // otherwise it clears when resolved
             cancelFunction = null;