@arrai-innovations/reactive-helpers 18.0.1 → 18.0.2

package/types/use/cancellableIntent.d.ts

@@ -0,0 +1,129 @@
+/**
+ * @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.
+ * @property {boolean} active - Whether there are active intents.
+ * @property {number} resolvingCount - The number of resolving intents.
+ * @property {boolean} resolving - Whether there are resolving intents.
+ * @property {boolean} errored - Whether there was an error.
+ * @property {Error} error - The error that occurred.
+ * @property {boolean} clearActiveOnResolved - Whether to clear the active state when the promise resolves.
+ */
+/**
+ * @typedef {object} CancellableIntentOptions - The options for the cancellable intent.
+ * @property {() => CancellablePromise} 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.
+ */
+/**
+ * @typedef {object} CancellableIntent - The instance of the cancellable intent.
+ * @property {CancellableIntentState} state - The state of the cancellable intent.
+ * @property {import('vue').UnwrapNestedRefs<object>} watchArguments - The watch arguments.
+ * @property {import('vue').UnwrapNestedRefs<object>} guardArguments - The guard arguments.
+ * @property {Function} stop - Stop the cancellable intent.
+ * @property {Function} cancel - Cancel the cancellable intent.
+ */
+/**
+ * Calls your awaitable function with the arguments you pass in when the watch arguments change and are all truthy.
+ * Watch arguments should be a reactive object.
+ * If the promise is not resolved before the watch arguments change again, the previous promise is cancelled.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useCancellableIntent } from "@vueda/use/cancellableIntent.js";
+ * import { ref, computed, onMounted, onUnmounted } from "vue";
+ *
+ * const myValue = ref(0);
+ * const myOtherValue = ref(0);
+ *
+ * const myIntent = useCancellableIntent({
+ *   awaitableWithCancel: async () => {
+ *     await new Promise((resolve) => setTimeout(resolve, 1000));
+ *     console.log("resolved");
+ *     return true;
+ *   },
+ *   watchArguments: { myValue, myOtherValue },
+ *   guardArguments: { myValue: computed(() => myValue.value > 0) },
+ *   clearActiveOnResolved: true,
+ * });
+ *
+ * onMounted(() => {
+ *   setTimeout(() => {
+ *     myValue.value = 1;
+ *     myOtherValue.value = 1;
+ *   }, 500);
+ * });
+ *
+ * onUnmounted(() => myIntent.stop());
+ * </script>
+ * ```
+ * @param {CancellableIntentOptions} options - The options for the cancellable intent.
+ * @returns {CancellableIntent} - The instance of the cancellable intent.
+ */
+export function useCancellableIntent({ awaitableWithCancel, watchArguments, guardArguments, clearActiveOnResolved, }: CancellableIntentOptions): CancellableIntent;
+/**
+ * A Promise that can be cancelled.
+ */
+export type CancellablePromise = Promise<any> & {
+    cancel: () => Promise<void> | void;
+};
+/**
+ * - The state of the cancellable intent.
+ */
+export type CancellableIntentState = import("vue").UnwrapNestedRefs<object>;
+/**
+ * - The options for the cancellable intent.
+ */
+export type CancellableIntentOptions = {
+    /**
+     * - The function that returns a promise that can be cancelled.
+     */
+    awaitableWithCancel: () => CancellablePromise;
+    /**
+     * - The reactive object to watch for changes.
+     */
+    watchArguments?: import("vue").UnwrapNestedRefs<object>;
+    /**
+     * - The reactive object to watch for truthiness before running the intent.
+     */
+    guardArguments?: import("vue").UnwrapNestedRefs<object>;
+    /**
+     * - Whether to clear the active state when the promise resolves.
+     */
+    clearActiveOnResolved?: boolean;
+};
+/**
+ * - The instance of the cancellable intent.
+ */
+export type CancellableIntent = {
+    /**
+     * - The state of the cancellable intent.
+     */
+    state: CancellableIntentState;
+    /**
+     * - The watch arguments.
+     */
+    watchArguments: import("vue").UnwrapNestedRefs<object>;
+    /**
+     * - The guard arguments.
+     */
+    guardArguments: import("vue").UnwrapNestedRefs<object>;
+    /**
+     * - Stop the cancellable intent.
+     */
+    stop: Function;
+    /**
+     * - Cancel the cancellable intent.
+     */
+    cancel: Function;
+};
+//# sourceMappingURL=cancellableIntent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cancellableIntent.d.ts","sourceRoot":"","sources":["../../use/cancellableIntent.js"],"names":[],"mappings":"AAOA;;GAEG;AAEH;;;;GAIG;AAEH;;;;;;;;;GASG;AAEH;;;;;;GAMG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,sHAHW,wBAAwB,GACtB,iBAAiB,CAwL7B;;;;iCA3PY,OAAO,CAAC,GAAG,CAAC,GAAG;IAAE,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAC,IAAI,CAAA;CAAE;;;;qCAInD,OAAO,KAAK,EAAE,gBAAgB,CAAC,MAAM,CAAC;;;;;;;;yBAYrC,MAAM,kBAAkB;;;;qBACxB,OAAO,KAAK,EAAE,gBAAgB,CAAC,MAAM,CAAC;;;;qBACtC,OAAO,KAAK,EAAE,gBAAgB,CAAC,MAAM,CAAC;;;;4BACtC,OAAO;;;;;;;;;WAKP,sBAAsB;;;;oBACtB,OAAO,KAAK,EAAE,gBAAgB,CAAC,MAAM,CAAC;;;;oBACtC,OAAO,KAAK,EAAE,gBAAgB,CAAC,MAAM,CAAC"}

package/types/use/combineClasses.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @typedef {(
+ *     string |
+ *     string[] |
+ *     { [key: string]: boolean | import("vue").Ref<boolean> } |
+ *     import("vue").Ref<string | string[]>
+ * )} CSSClasses
+ */
+/**
+ * Normalize various ways of specifying CSS classes into an object for use in Vue.js with reactivity. If refs are
+ *  present, the resulting object will be a ref containing an array of objects to preserve order of operations in
+ *  reactive contexts.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useCombineClasses } from "@vueda/use/combineClasses.js";
+ * import { ref } from "vue";
+ * const myClasses = useCombineClasses(
+ *     "class1",
+ *     ["class2", "class3"],
+ *     { class4: true, class5: false },
+ *     ref("class6"),
+ *     ref(["class7", "class8"]),
+ *     ref({ class9: true, class10: false }),
+ * );
+ * // myClasses.value = [
+ * //     { class1: true, class2: true, class3: true, class4: true, class5: false },
+ * //     { class6: true, class7: true, class8: true, class9: true, class10: false }
+ * // ]
+ * </script>
+ * ```
+ *
+ * @param {...(CSSClasses)} classes - A mixed array containing multiple ways of specifying CSS classes.
+ * @returns {import("vue").Ref<import('../utils/classes.js').CombinedClasses>} - A ref
+ *  containing an object or array of objects containing CSS classes. Arrays are used if refs are present, to
+ *  preserve order of operations in reactive contexts.
+ */
+export function useCombineClasses(...classes: (CSSClasses)[]): import("vue").Ref<import("../utils/classes.js").CombinedClasses>;
+export type CSSClasses = (string | string[] | {
+    [key: string]: boolean | import("vue").Ref<boolean>;
+} | import("vue").Ref<string | string[]>);
+//# sourceMappingURL=combineClasses.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"combineClasses.d.ts","sourceRoot":"","sources":["../../use/combineClasses.js"],"names":[],"mappings":"AAiBA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,8CALc,CAAC,UAAU,CAAC,EAAA,GACb,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,qBAAqB,EAAE,eAAe,CAAC,CAyB5E;yBA3DY,CACZ,MAAY,GACZ,MAAY,EAAE,GACd;IAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;CAAE,GAC7D,OAAa,KAAK,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CACvC"}

package/types/use/list.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Provides a comprehensive Vue 3 composable function for managing a list of objects. This module orchestrates several
+ * list-related functionalities including instance creation, subscriptions, relationships, calculations, filtering, searching,
+ * and sorting. It's designed to handle complex state management seamlessly in larger applications, ensuring optimal
+ * performance and reactivity.
+ *
+ * @module use/list.js
+ */
+/**
+ * Custom error class for use list errors.
+ */
+export class ListError extends Error {
+    /**
+     * Creates a new ListError.
+     *
+     * @param {string} message - The error message.
+     * @param {string} code - The error code.
+     */
+    constructor(message: string, code: string);
+    code: string;
+}
+export function useLists(listOptions: {
+    [key: string]: ListOptions;
+}): {
+    [key: string]: ListManager;
+};
+export function useList({ props, functions, paged, keepOldPages, clearListOnListIntentTriggered, searchThrottle, sortThrottleWait, searchShowAllWhenEmpty, }: ListOptions): ListManager;
+/**
+ * Defines properties for configuring the list management system.
+ */
+export type ListRawProps = {
+    /**
+     * - The arguments to pass to the registered list crud functions, related to the list itself.
+     */
+    listArgs: object;
+    /**
+     * - The primary key for the list items.
+     */
+    pkKey: string;
+    /**
+     * - The arguments to pass to the registered list crud functions, related to the items.
+     */
+    retrieveArgs: object;
+    /**
+     * - General arguments to pass to the registered list crud functions, often related to endpoints.
+     */
+    crudArgs: object;
+    /**
+     * - Indicates whether the list should be fetched immediately.
+     */
+    intendToList: boolean;
+    /**
+     * - Indicates whether changes to the list should be subscribed to.
+     */
+    intendToSubscribe: boolean;
+    /**
+     * - Defines rules for associating related objects with list items.
+     */
+    relatedObjectsRules: import("./listRelated.js").ListRelatedRules;
+    /**
+     * - Defines rules for dynamically calculating properties of list items.
+     */
+    calculatedObjectsRules: import("./listCalculated.js").ListCalculatedRules;
+    /**
+     * - Function or rule to determine if an item should be included based on inclusion criteria.
+     */
+    allowedFilter: import("./listFilter.js").ListFilterAllowedFilter;
+    /**
+     * - Function or rule to determine if an item should be excluded based on exclusion criteria.
+     */
+    excludedFilter: import("./listFilter.js").ListFilterExcludedFilter;
+    /**
+     * - Defines the properties and conditions used to filter the list via text search.
+     */
+    textSearchRules: import("./listSearch.js").TextSearchRules;
+    /**
+     * - Current text query used for filtering the list.
+     */
+    textSearchValue: string;
+    /**
+     * - FlexSearch document configuration options for advanced searching capabilities.
+     */
+    customDocumentOptions: object;
+    /**
+     * - Additional search options for FlexSearch.
+     */
+    customSearchOptions: object;
+    /**
+     * - Sorting rules that define the order of list items.
+     */
+    orderByRules: import("./listSort.js").OrderByRule[];
+};
+export type ListOptions = {
+    /**
+     * - The properties for configuring the list.
+     */
+    props: ListRawProps;
+    /**
+     * - Additional functions to be included in the list manager.
+     */
+    functions: import("../config/listCrud.js").ListCrudFunctions;
+    /**
+     * - Indicates whether the list should be paginated.
+     */
+    paged: boolean;
+    /**
+     * - Indicates whether old pages should be kept when paginating.
+     */
+    keepOldPages: boolean;
+    /**
+     * - Indicates whether the list should be cleared when the list intent is triggered.
+     */
+    clearListOnListIntentTriggered: boolean;
+    /**
+     * - The throttle time for text search.
+     */
+    searchThrottle: number;
+    /**
+     * - The throttle time for sorting.
+     */
+    sortThrottleWait: number;
+    /**
+     * - Indicates whether all items should be shown when the search query is empty.
+     */
+    searchShowAllWhenEmpty: boolean;
+};
+/**
+ * Represents the combined state definitions for all list-related components.
+ * This interface aggregates the raw state from multiple list management functionalities.
+ */
+export type ListRawState = (import("./listInstance.js").ListInstanceRawState | import("./listSubscription.js").ListSubscriptionRawState | import("./listRelated.js").ListRelatedRawState | import("./listCalculated.js").ListCalculatedRawState | import("./listFilter.js").ListFilterRawState | import("./listSearch.js").ListSearchRawState | import("./listSort.js").ListSortRawState);
+/**
+ * Represents the reactive state derived from aggregating states of various list-related components.
+ * This state is typically used within Vue components for reactivity and access to updated list properties.
+ */
+export type ListState = import("vue").UnwrapNestedRefs<ListRawState>;
+/**
+ * Holds references to instances of all list-related composables, facilitating direct access and management.
+ */
+export type ListManaged = {
+    listInstance: import("./listInstance.js").ListInstance;
+    listSubscription: import("./listSubscription.js").ListSubscription;
+    listRelated: import("./listRelated.js").ListRelated;
+    listCalculated: import("./listCalculated.js").ListCalculated;
+    listFilter: import("./listFilter.js").ListFilter;
+    listSearch: import("./listSearch.js").ListSearch;
+    listSort: import("./listSort.js").ListSort;
+};
+/**
+ * Aggregates all functions provided by various list-related composables, allowing for a unified approach to calling these methods.
+ */
+export type ListFunctions = (import("./listInstance.js").ListInstanceFunctions & import("./listSubscription.js").ListSubscriptionFunctions);
+/**
+ * Encapsulates properties relevant to the overall management of list-related hooks, including state, direct access to hooks,
+ * and scoped effects.
+ */
+export type ListManagerProperties = {
+    /**
+     * - A readonly reference to the managed list hooks.
+     */
+    managed: ListManaged;
+    /**
+     * - Represents the final reactive state in the list processing chain.
+     */
+    state: ListState;
+    /**
+     * - Encapsulates all reactive effects related to the list hooks.
+     */
+    effectScope: import("vue").EffectScope;
+};
+/**
+ * Combines functionality and properties to represent a fully managed list instance,
+ * orchestrating various functionalities such as sorting, searching, filtering, and state management.
+ */
+export type ListManager = ListFunctions & ListManagerProperties;
+//# sourceMappingURL=list.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../use/list.js"],"names":[],"mappings":"AAmBA;;;;;;;GAOG;AAEH;;GAEG;AACH;IACI;;;;;OAKG;IACH,qBAHW,MAAM,QACN,MAAM,EAMhB;IADG,aAAgB;CAEvB;AAiHM,sCAPI;IACV,CAAO,GAAG,EAAE,MAAM,GAAG,WAAW,CAAA;CAC7B,GACS;IACZ,CAAM,GAAG,EAAE,MAAM,GAAG,WAAW,CAAA;CAC5B,CASH;AAcM,8JAJI,WAAW,GACT,WAAW,CA2HvB;;;;;;;;cAxPa,MAAM;;;;WACN,MAAM;;;;kBACN,MAAM;;;;cACN,MAAM;;;;kBACN,OAAO;;;;uBACP,OAAO;;;;yBACP,OAAO,kBAAkB,EAAE,gBAAgB;;;;4BAC3C,OAAO,qBAAqB,EAAE,mBAAmB;;;;mBACjD,OAAO,iBAAiB,EAAE,uBAAuB;;;;oBACjD,OAAO,iBAAiB,EAAE,wBAAwB;;;;qBAClD,OAAO,iBAAiB,EAAE,eAAe;;;;qBACzC,MAAM;;;;2BACN,MAAM;;;;yBACN,MAAM;;;;kBACN,OAAO,eAAe,EAAE,WAAW,EAAE;;;;;;WAKrC,YAAY;;;;eACZ,OAAO,uBAAuB,EAAE,iBAAiB;;;;WACjD,OAAO;;;;kBACP,OAAO;;;;oCACP,OAAO;;;;oBACP,MAAM;;;;sBACN,MAAM;;;;4BACN,OAAO;;;;;;2BAOR,CACZ,OAAa,mBAAmB,EAAE,oBAAoB,GACtD,OAAa,uBAAuB,EAAE,wBAAwB,GAC9D,OAAa,kBAAkB,EAAE,mBAAmB,GACpD,OAAa,qBAAqB,EAAE,sBAAsB,GAC1D,OAAa,iBAAiB,EAAE,kBAAkB,GAClD,OAAa,iBAAiB,EAAE,kBAAkB,GAClD,OAAa,eAAe,EAAE,gBAAgB,CAC3C;;;;;wBAOS,OAAO,KAAK,EAAE,gBAAgB,CAAC,YAAY,CAAC;;;;0BAM5C;IACN,YAAY,EAAE,OAAO,mBAAmB,EAAE,YAAY,CAAC;IACvD,gBAAgB,EAAE,OAAO,uBAAuB,EAAE,gBAAgB,CAAC;IACnE,WAAW,EAAE,OAAO,kBAAkB,EAAE,WAAW,CAAC;IACpD,cAAc,EAAE,OAAO,qBAAqB,EAAE,cAAc,CAAC;IAC7D,UAAU,EAAE,OAAO,iBAAiB,EAAE,UAAU,CAAC;IACjD,UAAU,EAAE,OAAO,iBAAiB,EAAE,UAAU,CAAC;IACjD,QAAQ,EAAE,OAAO,eAAe,EAAE,QAAQ,CAAA;CAC7C;;;;4BAMS,CACZ,OAAa,mBAAmB,EAAE,qBAAqB,GAC/C,OAAO,uBAAuB,EAAE,yBAAyB,CAC9D;;;;;;;;;aAcU,WAAW;;;;WACX,SAAS;;;;iBACT,OAAO,KAAK,EAAE,WAAW;;;;;;0BAO1B,aAAa,GAAG,qBAAqB"}

package/types/use/listCalculated.d.ts

@@ -0,0 +1,192 @@
+/**
+ * The options to create a list calculated composition function.
+ *
+ * @typedef {object} ListCalculatedOptions - Options to configure the behavior of the list calculated properties.
+ * @property {ListCalculatedParentState} parentState - The parent state that interacts with the calculated objects.
+ * @property {ListCalculatedRules} calculatedObjectsRules - A reactive reference to rules used for dynamic calculations
+ *  within list objects. Proper setup of this reference ensures that updates are managed reactively, including deep
+ *  property changes.
+ */
+/**
+ * The properties for the list computed composition function.
+ *
+ * @typedef {object} ListCalculatedProperties
+ * @property {ListCalculatedState} state - The state for the list calculated property.
+ * @property {ListCalculatedParentState} parentState - The parent state object.
+ * @property {import('./watchesRunning.js').WatchesRunning} watchesRunning - The watches running.
+ * @property {import('vue').EffectScope} effectScope - The effect scope for the list calculated property.
+ */
+/**
+ * The instance of `useListCalculated`.
+ *
+ * @typedef {ListCalculatedProperties} ListCalculated
+ */
+/**
+ * A composable function to create multiple list calculated objects.
+ *
+ * @param {{
+ *     [key: string]: ListCalculatedOptions
+ * }} listCalculatedArgs - The arguments for the list calculated objects.
+ * @returns {{[key: string]: ListCalculated}} - The list calculated objects.
+ */
+export function useListCalculateds(listCalculatedArgs: {
+    [key: string]: ListCalculatedOptions;
+}): {
+    [key: string]: ListCalculated;
+};
+/**
+ * Initializes and manages a calculated properties object for lists. This function sets up reactive states and computations
+ * that dynamically update as specified in `calculatedObjectsRules`. It is used to add derived properties to list items,
+ * which depend on complex calculations or interactions between multiple objects in the list. These derived properties
+ * are reactive and will update in real-time as the underlying data changes, which is essential for maintaining data
+ * consistency in dynamic UIs.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useListSubscription, useListCalculated } from "@arrai-innovations/reactive-helpers";
+ * import { reactive, toRef } from "vue";
+ *
+ * const listSubscriptionProps = reactive({
+ *     // whatever props you need to get the list to work with your crud implementation
+ *     crudArgs: {},
+ *     listArgs: {},
+ *     pkKey: "pk",
+ *     retrieveArgs: {},
+ *     intendToList: true,
+ * });
+ * const listSubscription = useListSubscription(listSubscriptionProps);
+ * const listCalculatedProps = reactive({
+ *     parentState: listSubscription.state,
+ *     computedObjectsRules: {
+ *         someRule: (object, relatedObjects, calculatedObjects) => {
+ *            // some complex calculation, relatedObjects would be assuming there was a listRelated between the two
+ *            // calculatedObjects would be the other calculated objects in the list
+ *            // including yourself, so try not to create circular dependencies
+ *            // this is used as a computed body.
+ *            return object.someProperty + object.someOtherProperty;
+ *         }
+ *     },
+ * });
+ * const listCalculated = useListCalculated(listCalculatedProps);
+ * </script>
+ * <template>
+ *     <ul>
+ *         <!-- reactive list of objects, re-retrieving the list as someListFilter changes. -->
+ *         <li v-for="obj in listInstance.state.objectsInOrder">
+ *             {{ obj }}
+ *             <div>
+ *                 <!-- the computed object or objects based on the rule -->
+ *                 {{ listCalculated.state.computedObjects[obj.pk].someRule }}
+ *             </div>
+ *         </li>
+ *     </ul>
+ * </template>
+ * ```
+ *
+ * @param {ListCalculatedOptions} options - Configuration options including the parent state and rules for dynamically
+ *  generating calculated properties. This setup allows the system to handle calculations as part of the list management
+ *  process, ensuring that all related data is consistently updated.
+ * @returns {ListCalculated} - A reactive instance that manages and provides access to calculated properties within the
+ *  list, facilitating real-time updates and complex dependency management across multiple components.
+ */
+export function useListCalculated({ parentState, calculatedObjectsRules }: ListCalculatedOptions): ListCalculated;
+/**
+ * - Options to configure the behavior of the list calculated properties.
+ */
+export type ListCalculatedOptions = {
+    /**
+     * - The parent state that interacts with the calculated objects.
+     */
+    parentState: ListCalculatedParentState;
+    /**
+     * - A reactive reference to rules used for dynamic calculations
+     * within list objects. Proper setup of this reference ensures that updates are managed reactively, including deep
+     * property changes.
+     */
+    calculatedObjectsRules: ListCalculatedRules;
+};
+/**
+ * The properties for the list computed composition function.
+ */
+export type ListCalculatedProperties = {
+    /**
+     * - The state for the list calculated property.
+     */
+    state: ListCalculatedState;
+    /**
+     * - The parent state object.
+     */
+    parentState: ListCalculatedParentState;
+    /**
+     * - The watches running.
+     */
+    watchesRunning: import("./watchesRunning.js").WatchesRunning;
+    /**
+     * - The effect scope for the list calculated property.
+     */
+    effectScope: import("vue").EffectScope;
+};
+/**
+ * The instance of `useListCalculated`.
+ */
+export type ListCalculated = ListCalculatedProperties;
+/**
+ * Defines rules for dynamically calculating new properties for objects in a list. Each rule is a function that takes an
+ *  object from the list, optionally its related objects, and previously calculated properties to compute a new
+ *  property. These functions are reactive and re-evaluate when underlying dependencies change.
+ */
+export type ListCalculatedRules = import("vue").Ref<{
+    [rule: string]: (object: import("./listInstance.js").ListObject, relatedObject: {
+        [rule: string]: any;
+    }, calculatedObjects: {
+        [rule: string]: import("vue").ComputedRef<any>;
+    }) => any;
+}>;
+/**
+ * - The raw state for a list calculated property.
+ */
+export type ListCalculatedRawState = {
+    /**
+     * - The calculated objects.
+     */
+    calculatedObjects: {
+        [pk: string]: {
+            [rule: string]: import("vue").ComputedRef<any>;
+        };
+    };
+    /**
+     * - The rules for the calculated objects.
+     */
+    calculatedObjectsRules: ListCalculatedRules;
+    /**
+     * - Whether the parent state objects watch is running.
+     */
+    calculatedObjectsParentStateObjectsWatchRunning: boolean;
+    /**
+     * - Whether the calculated objects watch is running.
+     */
+    calculatedObjectsWatchRunning: boolean;
+    /**
+     * - Whether the calculated properties are running.
+     */
+    calculatedRunning: boolean;
+    /**
+     * - Whether the list is running.
+     */
+    running: import("vue").Ref<boolean>;
+};
+/**
+ * The raw parent state for a list calculated.
+ */
+export type ListCalculatedParentRawState = (import("./listInstance.js").ListInstanceRawState & Partial<import("./listSubscription.js").ListSubscriptionRawState> & Partial<import("./listRelated.js").ListRelatedRawState>);
+/**
+ * The state for a list calculated property.
+ */
+export type ListCalculatedState = import("vue").UnwrapNestedRefs<ListCalculatedParentRawState & ListCalculatedRawState>;
+/**
+ * Represents a combined reactive state that includes properties from list related,
+ *  subscription, and instance modules.
+ */
+export type ListCalculatedParentState = import("vue").UnwrapNestedRefs<(import("./listInstance.js").ListInstanceRawState & Partial<import("./listSubscription.js").ListSubscriptionRawState> & Partial<import("./listRelated.js").ListRelatedRawState>)>;
+//# sourceMappingURL=listCalculated.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"listCalculated.d.ts","sourceRoot":"","sources":["../../use/listCalculated.js"],"names":[],"mappings":"AAoGA;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AAIH;;;;GAIG;AAEH;;;;;;;GAOG;AACH,uDALW;IACV,CAAO,GAAG,EAAE,MAAM,GAAG,qBAAqB,CAAA;CACvC,GACS;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAAA;CAAC,CAS3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,2EANW,qBAAqB,GAGnB,cAAc,CAqI1B;;;;;;;;iBAnOa,yBAAyB;;;;;;4BACzB,mBAAmB;;;;;;;;;WASnB,mBAAmB;;;;iBACnB,yBAAyB;;;;oBACzB,OAAO,qBAAqB,EAAE,cAAc;;;;iBAC5C,OAAO,KAAK,EAAE,WAAW;;;;;6BAQ1B,wBAAwB;;;;;;kCA9FxB,OAAO,KAAK,EAAE,GAAG,CAAC;IAC9B,CAAO,IAAI,EAAE,MAAM,GAAG,CACZ,MAAM,EAAE,OAAO,mBAAmB,EAAE,UAAU,EAC9C,aAAa,EAAE;QACzB,CAAe,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC;KACvB,EACD,iBAAiB,EAAE;QAC7B,CAAe,IAAI,EAAE,MAAM,GAAG,OAAO,KAAK,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;KAClD,KACA,GAAG,CAAC;CACZ,CAAC;;;;;;;;uBAQS;QAAC,CAAC,EAAE,EAAE,MAAM,GAAG;YAAC,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,KAAK,EAAE,WAAW,CAAC,GAAG,CAAC,CAAA;SAAC,CAAA;KAAC;;;;4BAChE,mBAAmB;;;;qDACnB,OAAO;;;;mCACP,OAAO;;;;uBACP,OAAO;;;;aACP,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC;;;;;2CAO3B,CACZ,OAAa,mBAAmB,EAAE,oBAAoB,GAChD,OAAO,CAAC,OAAO,uBAAuB,EAAE,wBAAwB,CAAC,GACjE,OAAO,CAAC,OAAO,kBAAkB,EAAE,mBAAmB,CAAC,CAC1D;;;;kCAMS,OAAO,KAAK,EAAE,gBAAgB,CACpC,4BAA4B,GAC5B,sBAAsB,CACzB;;;;;wCAOS,OAAO,KAAK,EAAE,gBAAgB,CAAC,CAC3C,OAAa,mBAAmB,EAAE,oBAAoB,GAChD,OAAO,CAAC,OAAO,uBAAuB,EAAE,wBAAwB,CAAC,GACjE,OAAO,CAAC,OAAO,kBAAkB,EAAE,mBAAmB,CAAC,CAC1D,CAAC"}