@arrai-innovations/reactive-helpers 21.1.2 → 22.0.0

package/types/use/listSearch.d.ts

@@ -8,9 +8,7 @@
  * @module use/listSearch.js
  */
 /**
- * Represents the raw reactive state used by the list search functionality.
- *
- * @typedef {object} ListSearchRawState
+ * @typedef {object} ListSearchRawState - Represents the raw reactive state used by the list search functionality.
  * @property {import('./listInstance.js').ObjectsByPk} objects - Currently filtered objects based on the search.
  * @property {import('./listInstance.js').ObjectsInOrder} objectsInOrder - The list of objects sorted according to the current search criteria.
  * @property {import('./listInstance.js').ListOrder} order - The current sort order of object pks after search have been applied.
@@ -32,13 +30,13 @@
  *     Partial<import('./listRelated.js').ListRelatedRawState> &
  *     Partial<import('./listCalculated.js').ListCalculatedRawState> &
  *     Partial<import('./listFilter.js').ListFilterRawState>
- * )} ListSearchParentRawState
+ * )} ListSearchParentRawState - The raw, pre-unwrapped parent state consumed by the list search mixin, aggregating the upstream list composable states.
  */
 /**
  * @typedef {import('vue').UnwrapNestedRefs<ListSearchParentRawState>} ListSearchParentState - The parent state for a list search.
  */
 /**
- *  @typedef {import('vue').ToRefs<ListSearchParentState>} ListSearchParentStateToRefs
+ *  @typedef {import('vue').ToRefs<ListSearchParentState>} ListSearchParentStateToRefs - The parent list-search state converted to individual Vue refs.
  */
 /**
  * @typedef {import('vue').UnwrapNestedRefs<
@@ -66,17 +64,13 @@
  * @property {boolean} [showAllWhenEmpty=true] - Whether to show all items when the search is empty.
  */
 /**
- * The properties on a list search instance.
- *
- * @typedef {object} ListSearchProperties
+ * @typedef {object} ListSearchProperties - The properties on a list search instance.
  * @property {ListSearchState} state - The state.
  * @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.
- *
- * @typedef {ListSearchProperties} ListSearch
+ * @typedef {ListSearchProperties} ListSearch - The provided list search instance, containing properties and functions.
  */
 /**
  * Helper function that initializes multiple list search instances from given configurations. This is typically used
@@ -95,13 +89,10 @@ export function useListSearches(listSearchArgs: {
     [key: string]: ListSearch;
 };
 /**
- * FlexSearch.Document options, specifically for .index. Their documentation isn't very clear on this.
- * Typically, it would be a list of dot-separated keys to index.
- *
- * @typedef {string | string[] | object[]} TextSearchRules
+ * @typedef {string | string[] | object[]} TextSearchRules - FlexSearch.Document options, specifically for .index. Their documentation isn't very clear on this. Typically, it would be a list of dot-separated keys to index.
  */
 /**
- * @typedef {object} ListSearchProps
+ * @typedef {object} ListSearchProps - The consumer-supplied props configuring a list's text search (rules, value, and FlexSearch options).
  * @property {TextSearchRules} textSearchRules - Rules for what to search for. Keys are the keys to search for, values are functions that take the object and return The value to search for.
  * @property {string} textSearchValue - The value to search for.
  * @property {object} customDocumentOptions - FlexSearch.Document options.
@@ -109,7 +100,7 @@ export function useListSearches(listSearchArgs: {
  * @property {object} [customSearchOptions.limit=1000] - FlexSearch.Search options.
  */
 /**
- * @typedef {object} ListSearchInstanceOptions
+ * @typedef {object} ListSearchInstanceOptions - The configuration options used to create a list search instance.
  * @property {object} parentState - The list being filtered.
  * @property {ListSearchProps} [props] - Reactive properties.
  * @property {number} [throttle=500] - Throttle wait time.
@@ -149,98 +140,104 @@ export function useListSearch({ parentState, props, throttle, showAllWhenEmpty }
  */
 export type ListSearchRawState = {
     /**
-     * - Currently filtered objects based on the search.
+     * Currently filtered objects based on the search.
      */
     objects: import("./listInstance.js").ObjectsByPk;
     /**
-     * - The list of objects sorted according to the current search criteria.
+     * The list of objects sorted according to the current search criteria.
      */
     objectsInOrder: import("./listInstance.js").ObjectsInOrder;
     /**
-     * - The current sort order of object pks after search have been applied.
+     * The current sort order of object pks after search have been applied.
      */
     order: import("./listInstance.js").ListOrder;
     /**
-     * - Rules defining how text search should be applied on list items. Each rule
+     * Rules defining how text search should be applied on list items. Each rule
      * specifies a key and a function to extract the searchable text.
      */
     textSearchRules: object;
     /**
-     * - The current value used for searching.
+     * The current value used for searching.
      */
     textSearchValue: string;
     /**
-     * - Indexes built for quick search across objects based on rules.
+     * Indexes built for quick search across objects based on rules.
      */
     objectIndexes: object;
     /**
-     * - Configuration options for the search document, used by FlexSearch.
+     * Configuration options for the search document, used by FlexSearch.
      */
     customDocumentOptions: object;
     /**
-     * - Additional search options for FlexSearch.
+     * Additional search options for FlexSearch.
      */
     customSearchOptions: object;
     /**
-     * - Flag indicating if a search has been performed.
+     * Flag indicating if a search has been performed.
      */
     searched: Readonly<import("vue").Ref<boolean>>;
     /**
-     * - Indicates if the search process is actively running.
+     * Indicates if the search process is actively running.
      */
     running: import("vue").ComputedRef<boolean>;
 };
+/**
+ * The raw, pre-unwrapped parent state consumed by the list search mixin, aggregating the upstream list composable states.
+ */
 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.
+ * The parent state for a list search.
  */
 export type ListSearchParentState = import("vue").UnwrapNestedRefs<ListSearchParentRawState>;
+/**
+ * The parent list-search state converted to individual Vue refs.
+ */
 export type ListSearchParentStateToRefs = import("vue").ToRefs<ListSearchParentState>;
 /**
- * - The state for a list search.
+ * The state for a list search.
  */
 export type ListSearchState = import("vue").UnwrapNestedRefs<ListSearchRawState & Partial<import("./listFilter.js").ListFilterRawState> & Partial<import("./listCalculated.js").ListCalculatedRawState> & Partial<import("./listRelated.js").ListRelatedRawState> & Partial<import("./listSubscription.js").ListSubscriptionRawState> & import("./listInstance.js").ListInstanceRawState>;
 /**
- * - The raw props for a list search.
+ * The raw props for a list search.
  */
 export type ListSearchRawProps = {
     /**
-     * - Rules for what to search for. Keys are the keys to search for, values are functions that take the object and return The value to search for.
+     * Rules for what to search for. Keys are the keys to search for, values are functions that take the object and return The value to search for.
      */
     textSearchRules: any[];
     /**
-     * - The value to search for.
+     * The value to search for.
      */
     textSearchValue: string;
     /**
-     * - FlexSearch.Document options.
+     * FlexSearch.Document options.
      */
     customDocumentOptions: object;
     /**
-     * - FlexSearch.Search options.
+     * FlexSearch.Search options.
      */
     customSearchOptions: {
         limit?: object;
     };
 };
 /**
- * - The options for a list search.
+ * The options for a list search.
  */
 export type ListSearchOptions = {
     /**
-     * - The parent state.
+     * The parent state.
      */
     parentState: ListSearchParentState;
     /**
-     * - The props.
+     * The props.
      */
     props: import("vue").UnwrapNestedRefs<ListSearchRawProps>;
     /**
-     * - The throttle.
+     * The throttle.
      */
     throttle?: number;
     /**
-     * - Whether to show all items when the search is empty.
+     * Whether to show all items when the search is empty.
      */
     showAllWhenEmpty?: boolean;
 };
@@ -249,15 +246,15 @@ export type ListSearchOptions = {
  */
 export type ListSearchProperties = {
     /**
-     * - The state.
+     * The state.
      */
     state: ListSearchState;
     /**
-     * - The text search index.
+     * The text search index.
      */
     textSearchIndex: import("./search.js").SearchInstance;
     /**
-     * - Stops the effect scope and cleans up resources.
+     * Stops the effect scope and cleans up resources.
      */
     stop: () => void;
 };
@@ -266,45 +263,50 @@ export type ListSearchProperties = {
  */
 export type ListSearch = ListSearchProperties;
 /**
- * FlexSearch.Document options, specifically for .index. Their documentation isn't very clear on this.
- * Typically, it would be a list of dot-separated keys to index.
+ * FlexSearch.Document options, specifically for .index. Their documentation isn't very clear on this. Typically, it would be a list of dot-separated keys to index.
  */
 export type TextSearchRules = string | string[] | object[];
+/**
+ * The consumer-supplied props configuring a list's text search (rules, value, and FlexSearch options).
+ */
 export type ListSearchProps = {
     /**
-     * - Rules for what to search for. Keys are the keys to search for, values are functions that take the object and return The value to search for.
+     * Rules for what to search for. Keys are the keys to search for, values are functions that take the object and return The value to search for.
      */
     textSearchRules: TextSearchRules;
     /**
-     * - The value to search for.
+     * The value to search for.
      */
     textSearchValue: string;
     /**
-     * - FlexSearch.Document options.
+     * FlexSearch.Document options.
      */
     customDocumentOptions: object;
     /**
-     * - FlexSearch.Search options.
+     * FlexSearch.Search options.
      */
     customSearchOptions: {
         limit?: object;
     };
 };
+/**
+ * The configuration options used to create a list search instance.
+ */
 export type ListSearchInstanceOptions = {
     /**
-     * - The list being filtered.
+     * The list being filtered.
      */
     parentState: object;
     /**
-     * - Reactive properties.
+     * Reactive properties.
      */
     props?: ListSearchProps;
     /**
-     * - Throttle wait time.
+     * Throttle wait time.
      */
     throttle?: number;
     /**
-     * - Whether to show all items when the search is empty.
+     * Whether to show all items when the search is empty.
      */
     showAllWhenEmpty?: boolean;
 };

package/types/use/listSort.d.ts

@@ -11,22 +11,15 @@ 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
+ * }} OrderByRule - 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.
  */
 /**
- * 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
+ * @typedef {object} ListSortRawState - Represents the raw state used by the list sorting functionality. Includes all configurations and state necessary to manage sorting operations within a Vue application.
  * @property {OrderByRule[]} orderByRules - Current sorting rules applied to the list.
  * @property {boolean[]} orderByDesc - Flags indicating whether each sort criterion is in descending order.
  */
@@ -40,40 +33,31 @@ export function setListSortDefaultOptions({ sortThrottleWait }: {
  *     Partial<import('./listCalculated.js').ListCalculatedRawState> &
  *     Partial<import('./listFilter.js').ListFilterRawState> &
  *     Partial<import('./listSearch.js').ListSearchRawState>
- * )} ListSortParentRawState
+ * )} ListSortParentRawState - The raw, pre-unwrapped parent state consumed by the list sort mixin, aggregating the upstream list composable states.
  */
 /**
- * @typedef {import('vue').UnwrapNestedRefs<ListSortParentRawState>} ListSortParentState
+ * @typedef {import('vue').UnwrapNestedRefs<ListSortParentRawState>} ListSortParentState - The unwrapped reactive parent state consumed by the list sort mixin.
  */
 /**
- * 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
+ * >} ListSortState - The reactive state used by the list sorting functionality. Includes all configurations and state necessary to manage sorting operations within a Vue application.
  */
 /**
- * The configuration options for initializing a list sort instance.
- *
- * @typedef {object} ListSortOptions
+ * @typedef {object} ListSortOptions - The configuration options for initializing a list sort instance.
  * @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
+ * @typedef {object} ListSortProperties - The properties available on a list sort instance.
  * @property {ListSortState} state - The reactive state for the list sort.
  * @property {ListSortParentState} parentState - The parent state.
  * @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.
- *
- * @typedef {ListSortProperties} ListSort
+ * @typedef {ListSortProperties} ListSort - The list sort instance, including reactive state and utilities to manage list sorting operations.
  */
 /**
  * Creates multiple list sort instances.
@@ -132,9 +116,7 @@ export function useListSorts(listSortArgs: {
  */
 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.
+ * 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;
@@ -143,24 +125,28 @@ export type OrderByRule = {
     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.
+ * 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.
+     * Current sorting rules applied to the list.
      */
     orderByRules: OrderByRule[];
     /**
-     * - Flags indicating whether each sort criterion is in descending order.
+     * Flags indicating whether each sort criterion is in descending order.
      */
     orderByDesc: boolean[];
 };
+/**
+ * The raw, pre-unwrapped parent state consumed by the list sort mixin, aggregating the upstream list composable states.
+ */
 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>);
+/**
+ * The unwrapped reactive parent state consumed by the list sort mixin.
+ */
 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.
+ * 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>;
 /**
@@ -168,15 +154,15 @@ export type ListSortState = import("vue").UnwrapNestedRefs<ListSortParentRawStat
  */
 export type ListSortOptions = {
     /**
-     * - The parent state containing the list data and any associated state needed for sorting.
+     * 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.
+     * 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.
+     * Optional throttle wait time to limit the frequency of sort operations, enhancing performance.
      */
     sortThrottleWait: number | symbol;
 };
@@ -185,15 +171,15 @@ export type ListSortOptions = {
  */
 export type ListSortProperties = {
     /**
-     * - The reactive state for the list sort.
+     * The reactive state for the list sort.
      */
     state: ListSortState;
     /**
-     * - The parent state.
+     * The parent state.
      */
     parentState: ListSortParentState;
     /**
-     * - A function to stop the effect scope and clean up resources.
+     * A function to stop the effect scope and clean up resources.
      */
     stop: () => void;
 };

package/types/use/listSubscription.d.ts

@@ -1,61 +1,46 @@
 /**
- * The raw state of a list subscription.
- *
- * @typedef {object} ListSubscriptionMyState
+ * @typedef {object} ListSubscriptionMyState - The raw state of a list subscription.
  * @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
+ * @typedef {import('vue').ToRefs<import('./listInstance.js').ListInstanceState>} ListInstanceStateRefs - The list instance's reactive state converted to individual Vue refs.
  */
 /**
- * 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
+ * ) & ListInstanceStateRefs} ListSubscriptionRawState - The raw state of a list subscription, including the state from the list instance.
  */
 /**
- * A reactive object that manages a list of objects, as returned by `useListInstance`.
- *
- * @typedef {import('vue').Reactive<ListSubscriptionRawState>} ListSubscriptionState
+ * @typedef {import('vue').Reactive<ListSubscriptionRawState>} ListSubscriptionState - A reactive object that manages a list of objects, as returned by `useListInstance`.
  */
 /**
- * The methods available on a list subscription.
- *
- * @typedef {Pick<import('./loadingError.js').LoadingErrorStatus, "clearError">} ListSubscriptionFunctions
+ * @typedef {Pick<import('./loadingError.js').LoadingErrorStatus, "clearError">} ListSubscriptionFunctions - The methods available on a list subscription.
  */
 /**
  * @typedef {{
  *     state: ListSubscriptionState,
  *     listInstance: import('./listInstance.js').ListInstance,
  *     loadingError: import('./loadingError.js').LoadingErrorStatus,
- * }} ListSubscriptionContext
+ * }} ListSubscriptionContext - The context (state, list instance, and loading/error status) bound to the shared list subscription functions.
  */
 /**
- * The properties of a list subscription.
- *
- * @typedef {object} ListSubscriptionProperties
+ * @typedef {object} ListSubscriptionProperties - The properties of a list subscription.
  * @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.
  */
 /**
- * An instance of a list subscription, returned by `useListSubscription`.
- *
- * @typedef {ListSubscriptionFunctions & ListSubscriptionProperties} ListSubscription
+ * @typedef {ListSubscriptionFunctions & ListSubscriptionProperties} ListSubscription - An instance of a list subscription, returned by `useListSubscription`.
  */
 /**
- * @typedef {object} ListSubscriptionOwnOptions
+ * @typedef {object} ListSubscriptionOwnOptions - The options specific to a list subscription, namely an optional pre-built list instance to reuse.
  * @property {import("./listInstance.js").ListInstance} [listInstance] - A list instance to use instead of creating one.
  */
 /**
- * Defines the settings required to establish a list subscription, detailing how list instances should handle updates
- *  and subscriptions based on the given properties.
- *
- * @typedef {import("./listInstance.js").ListInstanceOptions & ListSubscriptionOwnOptions} ListSubscriptionOptions
+ * @typedef {import("./listInstance.js").ListInstanceOptions & ListSubscriptionOwnOptions} ListSubscriptionOptions - Defines the settings required to establish a list subscription, detailing how list instances should handle updates and subscriptions based on the given properties.
  */
 /**
  * A Vue composition function that creates multiple list subscriptions, and returns them as an object.
@@ -139,18 +124,21 @@ export class ListSubscriptionError extends Error {
  */
 export type ListSubscriptionMyState = {
     /**
-     * - If this is true, the list should be fetched, or re-fetched if arguments change.
+     * If this is true, the list should be fetched, or re-fetched if arguments change.
      */
     intendToList: import("vue").Ref<boolean> | boolean;
     /**
-     * - If this is true, the subscription should start or restart if arguments change.
+     * If this is true, the subscription should start or restart if arguments change.
      */
     intendToSubscribe: import("vue").Ref<boolean> | boolean;
     /**
-     * - Whether the subscription is active.
+     * Whether the subscription is active.
      */
     subscribed: import("vue").Ref<boolean>;
 };
+/**
+ * The list instance's reactive state converted to individual Vue refs.
+ */
 export type ListInstanceStateRefs = import("vue").ToRefs<import("./listInstance.js").ListInstanceState>;
 /**
  * The raw state of a list subscription, including the state from the list instance.
@@ -164,6 +152,9 @@ export type ListSubscriptionState = import("vue").Reactive<ListSubscriptionRawSt
  * The methods available on a list subscription.
  */
 export type ListSubscriptionFunctions = Pick<import("./loadingError.js").LoadingErrorStatus, "clearError">;
+/**
+ * The context (state, list instance, and loading/error status) bound to the shared list subscription functions.
+ */
 export type ListSubscriptionContext = {
     state: ListSubscriptionState;
     listInstance: import("./listInstance.js").ListInstance;
@@ -174,19 +165,19 @@ export type ListSubscriptionContext = {
  */
 export type ListSubscriptionProperties = {
     /**
-     * - The reactive state of the list subscription.
+     * The reactive state of the list subscription.
      */
     state: ListSubscriptionState;
     /**
-     * - The list instance used by the subscription.
+     * The list instance used by the subscription.
      */
     listInstance: import("./listInstance.js").ListInstance;
     /**
-     * - The `CancellableIntent` instance managing if the list should be (re)fetched.
+     * 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.
+     * The `CancellableIntent` instance managing if the subscription should be (un)subscribed.
      */
     subscribeIntent: import("./cancellableIntent.js").CancellableIntent;
 };
@@ -194,14 +185,16 @@ export type ListSubscriptionProperties = {
  * An instance of a list subscription, returned by `useListSubscription`.
  */
 export type ListSubscription = ListSubscriptionFunctions & ListSubscriptionProperties;
+/**
+ * The options specific to a list subscription, namely an optional pre-built list instance to reuse.
+ */
 export type ListSubscriptionOwnOptions = {
     /**
-     * - A list instance to use instead of creating one.
+     * A list instance to use instead of creating one.
      */
     listInstance?: import("./listInstance.js").ListInstance;
 };
 /**
- * Defines the settings required to establish a list subscription, detailing how list instances should handle updates
- *  and subscriptions based on the given properties.
+ * 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 = import("./listInstance.js").ListInstanceOptions & ListSubscriptionOwnOptions;

package/types/use/loading.d.ts

@@ -1,20 +1,18 @@
 /**
- * @typedef {import("vue").Ref<boolean|undefined>} LoadingRef
- * @typedef {Readonly<LoadingRef>} LoadingReadonlyRef
+ * @typedef {import("vue").Ref<boolean|undefined>} LoadingRef - A Vue ref to the loading flag, which is a boolean or undefined.
+ * @typedef {Readonly<LoadingRef>} LoadingReadonlyRef - A readonly Vue ref to the loading flag, which is a boolean or undefined.
  */
 /**
- * @typedef {object} LoadingProperties
+ * @typedef {object} LoadingProperties - The reactive loading-state member (loading) contributed by the useLoading composable.
  * @property {LoadingReadonlyRef} loading - Whether the component is loading.
  */
 /**
- * @typedef {object} LoadingFunctions
+ * @typedef {object} LoadingFunctions - The loading-state actions (setLoading, clearLoading) contributed by the useLoading composable.
  * @property {() => void} setLoading - Set the loading state to true.
  * @property {() => void} clearLoading - Set the loading state to false.
  */
 /**
- * The loading state API.
- *
- * @typedef {LoadingProperties & LoadingFunctions} LoadingStatus
+ * @typedef {LoadingProperties & LoadingFunctions} LoadingStatus - The loading state API.
  */
 /**
  * A composable function for managing loading state.
@@ -22,21 +20,33 @@
  * @returns {LoadingStatus} - An object containing reactive fields and actions for loading state.
  */
 export function useLoading(): LoadingStatus;
+/**
+ * A Vue ref to the loading flag, which is a boolean or undefined.
+ */
 export type LoadingRef = import("vue").Ref<boolean | undefined>;
+/**
+ * A readonly Vue ref to the loading flag, which is a boolean or undefined.
+ */
 export type LoadingReadonlyRef = Readonly<LoadingRef>;
+/**
+ * The reactive loading-state member (loading) contributed by the useLoading composable.
+ */
 export type LoadingProperties = {
     /**
-     * - Whether the component is loading.
+     * Whether the component is loading.
      */
     loading: LoadingReadonlyRef;
 };
+/**
+ * The loading-state actions (setLoading, clearLoading) contributed by the useLoading composable.
+ */
 export type LoadingFunctions = {
     /**
-     * - Set the loading state to true.
+     * Set the loading state to true.
      */
     setLoading: () => void;
     /**
-     * - Set the loading state to false.
+     * Set the loading state to false.
      */
     clearLoading: () => void;
 };