@arrai-innovations/reactive-helpers 18.0.1 → 18.0.2

package/types/use/listFilter.d.ts

@@ -0,0 +1,203 @@
+/**
+ * @typedef {import('vue').Ref<import('./listInstance.js').ListObject>[]} ObjectsInOrderRefs
+ */
+/**
+ * @typedef {Function} ListFilterAllowedFilter - A function that returns true if an item should be included.
+ */
+/**
+ * @typedef {Function} ListFilterExcludedFilter - A function that returns true if an item should be excluded.
+ */
+/**
+ * Defines the structure of the reactive state used by the list filter. This state includes both filters and
+ * the results of applying these filters to a list.
+ *
+ * @typedef {object} ListFilterRawState
+ * @property {ListFilterAllowedFilter} [allowedFilter] - Function to determine if an item should be included based on custom logic.
+ * @property {ListFilterExcludedFilter} [excludedFilter] - Function to determine if an item should be excluded based on custom logic.
+ * @property {object} inResults - A map of items to boolean values indicating filter results.
+ * @property {boolean} objectsWatchRunning - Flag indicating if the object watch is active.
+ * @property {boolean} resultsWatchRunning - Flag indicating if the results watch is active.
+ * @property {boolean} running - Flag indicating if any part of the filter logic is currently processing.
+ * @property {boolean} orderWatchRunning - Flag indicating if the order watch is active.
+ */
+/**
+ *
+ *
+ * @typedef {(
+ *     import('./listInstance.js').ListInstanceRawState &
+ *     Partial<import('./listSubscription.js').ListSubscriptionRawState> &
+ *     Partial<import('./listRelated.js').ListRelatedRawState> &
+ *     Partial<import('./listCalculated.js').ListCalculatedRawState>
+ * )} ListFilterParentRawState
+ */
+/**
+ * The parent state for a list filter.
+ *
+ * @typedef {import('vue').UnwrapNestedRefs<(
+ *     ListFilterParentRawState
+ * )>} ListFilterParentState
+ */
+/**
+ * Describes the combined state from various list-related composables that might interact with the list filter.
+ *
+ * @typedef {import('vue').UnwrapNestedRefs<
+ *     ListFilterParentRawState &
+ *     ListFilterRawState
+ * >} ListFilterState
+ */
+/**
+ * Configuration options for initializing a list filter. Includes references to the parent state and filter functions.
+ *
+ * @typedef {object} ListFilterOptions
+ * @property {ListFilterParentState} parentState - The parent state.
+ * @property {import('vue').Ref<Function>|Function} [allowedFilter] - A function that returns true if an item should be included, which can be reactive.
+ * @property {import('vue').Ref<Function>|Function} [excludedFilter] - A function that returns true if an item should be excluded, which can be reactive.
+ */
+/**
+ * The properties of a list filter, including its state and associated Vue composition API utilities.
+ *
+ * @typedef {object} ListFilterProperties
+ * @property {ListFilterState} state - The reactive state managing the filter logic and results.
+ * @property {ListFilterParentState} parentState - The state of the list being filtered.
+ * @property {import('vue').EffectScope} effectScope - Scoped reactivity for this filter instance.
+ */
+/**
+ * Represents an instance of a list filter, including its state and associated Vue composition API utilities.
+ *
+ * @typedef {ListFilterProperties} ListFilter
+ *
+ */
+/**
+ * Helper function to create multiple instances of list filters based on provided configurations.
+ *
+ * @param {{[key: string]: ListFilterOptions}} listFilterArgs - Configuration for each filter instance.
+ * @returns {{[key: string]: ListFilter}} An object containing instances of list filters.
+ */
+export function useListFilters(listFilterArgs: {
+    [key: string]: ListFilterOptions;
+}): {
+    [key: string]: ListFilter;
+};
+/**
+ * Initializes and manages a list filter instance, setting up reactive states and dependencies
+ * to dynamically adjust the visible items based on the provided filter functions.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { defineProps, reactive, toRef, computed } from 'vue';
+ * import { useListInstance, useListFilter } from '@arrai-innovations/reactive-helpers';
+ *
+ * const props = defineProps({
+ *     someListFilter: String
+ * });
+ *
+ * const listInstance = useListInstance({ props });
+ * const filterConditions = reactive({
+ *     allowedFilter: (item) => item.isActive,
+ *     excludedFilter: (item) => !item.isValid
+ * });
+ *
+ * const listFilter = useListFilter({
+ *     parentState: listInstance.state,
+ *     ...filterConditions
+ * });
+ * // listFilter.state.objectsInOrder now contains the reactive filtered items from listInstance.state.objectsInOrder
+ * </script>
+ * ```
+ *
+ * @param {ListFilterOptions} options - The options for the list filter including filters and parent state.
+ * @returns {ListFilter} A fully configured list filter instance, providing reactive filtered results.
+ */
+export function useListFilter({ parentState, allowedFilter, excludedFilter }: ListFilterOptions): ListFilter;
+export type ObjectsInOrderRefs = import("vue").Ref<import("./listInstance.js").ListObject>[];
+/**
+ * - A function that returns true if an item should be included.
+ */
+export type ListFilterAllowedFilter = Function;
+/**
+ * - A function that returns true if an item should be excluded.
+ */
+export type ListFilterExcludedFilter = Function;
+/**
+ * Defines the structure of the reactive state used by the list filter. This state includes both filters and
+ * the results of applying these filters to a list.
+ */
+export type ListFilterRawState = {
+    /**
+     * - Function to determine if an item should be included based on custom logic.
+     */
+    allowedFilter?: ListFilterAllowedFilter;
+    /**
+     * - Function to determine if an item should be excluded based on custom logic.
+     */
+    excludedFilter?: ListFilterExcludedFilter;
+    /**
+     * - A map of items to boolean values indicating filter results.
+     */
+    inResults: object;
+    /**
+     * - Flag indicating if the object watch is active.
+     */
+    objectsWatchRunning: boolean;
+    /**
+     * - Flag indicating if the results watch is active.
+     */
+    resultsWatchRunning: boolean;
+    /**
+     * - Flag indicating if any part of the filter logic is currently processing.
+     */
+    running: boolean;
+    /**
+     * - Flag indicating if the order watch is active.
+     */
+    orderWatchRunning: boolean;
+};
+export type ListFilterParentRawState = (import("./listInstance.js").ListInstanceRawState & Partial<import("./listSubscription.js").ListSubscriptionRawState> & Partial<import("./listRelated.js").ListRelatedRawState> & Partial<import("./listCalculated.js").ListCalculatedRawState>);
+/**
+ * The parent state for a list filter.
+ */
+export type ListFilterParentState = import("vue").UnwrapNestedRefs<(ListFilterParentRawState)>;
+/**
+ * Describes the combined state from various list-related composables that might interact with the list filter.
+ */
+export type ListFilterState = import("vue").UnwrapNestedRefs<ListFilterParentRawState & ListFilterRawState>;
+/**
+ * Configuration options for initializing a list filter. Includes references to the parent state and filter functions.
+ */
+export type ListFilterOptions = {
+    /**
+     * - The parent state.
+     */
+    parentState: ListFilterParentState;
+    /**
+     * - A function that returns true if an item should be included, which can be reactive.
+     */
+    allowedFilter?: import("vue").Ref<Function> | Function;
+    /**
+     * - A function that returns true if an item should be excluded, which can be reactive.
+     */
+    excludedFilter?: import("vue").Ref<Function> | Function;
+};
+/**
+ * The properties of a list filter, including its state and associated Vue composition API utilities.
+ */
+export type ListFilterProperties = {
+    /**
+     * - The reactive state managing the filter logic and results.
+     */
+    state: ListFilterState;
+    /**
+     * - The state of the list being filtered.
+     */
+    parentState: ListFilterParentState;
+    /**
+     * - Scoped reactivity for this filter instance.
+     */
+    effectScope: import("vue").EffectScope;
+};
+/**
+ * Represents an instance of a list filter, including its state and associated Vue composition API utilities.
+ */
+export type ListFilter = ListFilterProperties;
+//# sourceMappingURL=listFilter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"listFilter.d.ts","sourceRoot":"","sources":["../../use/listFilter.js"],"names":[],"mappings":"AAqCA;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;GASG;AAEH;;;;;;GAMG;AAEH;;;;;;;GAOG;AAEH;;;;;;;GAOG;AAEH;;;;;;;GAOG;AAIH;;;;;GAKG;AAEH;;;;;GAKG;AACH,+CAHW;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAAA;CAAC,GAChC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;CAAC,CASvC;AAeD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,8EAHW,iBAAiB,GACf,UAAU,CAiKtB;iCA1SY,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,mBAAmB,EAAE,UAAU,CAAC,EAAE;;;;;;;;;;;;;;;;;oBAgB1D,uBAAuB;;;;qBACvB,wBAAwB;;;;eACxB,MAAM;;;;yBACN,OAAO;;;;yBACP,OAAO;;;;aACP,OAAO;;;;uBACP,OAAO;;uCAMR,CACZ,OAAa,mBAAmB,EAAE,oBAAoB,GAChD,OAAO,CAAC,OAAO,uBAAuB,EAAE,wBAAwB,CAAC,GACjE,OAAO,CAAC,OAAO,kBAAkB,EAAE,mBAAmB,CAAC,GACvD,OAAO,CAAC,OAAO,qBAAqB,EAAE,sBAAsB,CAAC,CAChE;;;;oCAMS,OAAO,KAAK,EAAE,gBAAgB,CAAC,CACrC,wBAAwB,CAC3B,CAAC;;;;8BAMQ,OAAO,KAAK,EAAE,gBAAgB,CACpC,wBAAwB,GACxB,kBAAkB,CACrB;;;;;;;;iBAOU,qBAAqB;;;;oBACrB,OAAO,KAAK,EAAE,GAAG,UAAU,WAAS;;;;qBACpC,OAAO,KAAK,EAAE,GAAG,UAAU,WAAS;;;;;;;;;WAOpC,eAAe;;;;iBACf,qBAAqB;;;;iBACrB,OAAO,KAAK,EAAE,WAAW;;;;;yBAQ1B,oBAAoB"}

package/types/use/listInstance.d.ts

@@ -0,0 +1,357 @@
+/**
+ * The reactive arguments for the list instance.
+ *
+ * @typedef {object} ListInstanceProps
+ * @property {string} pkKey - The primary key field for the list objects.
+ * @property {object} retrieveArgs - The arguments passed to the server.
+ * @property {object} listArgs - The arguments passed to the server.
+ * @property {object} crudArgs - Implementation specific arguments.
+ */
+/**
+ * The configuration options used to create a list instance.
+ *
+ * @typedef {object} ListInstanceOptions
+ * @property {import('vue').UnwrapNestedRefs<ListInstanceProps>} props - The props for the list instance.
+ * @property {object} [functions] - Default implementation are used as set by `setListCrud`.
+ * @property {import('../config/listCrud.js').ListFn} [functions.list] - Provide the implementation for the list
+ *  function.
+ *  @property {import('../config/listCrud.js').BulkDeleteFn} [functions.bulkDelete] - Provide the implementation for the bulkDelete
+ *  function.
+ *   @property {import('../config/listCrud.js').ExecuteActionFn} [functions.executeAction] - Provide the implementation for the executeAction
+ *  function.
+ * @property {import('../config/listCrud.js').SubscribeFn} [functions.subscribe] - Provide the implementation for the
+ *  subscribe function.
+ * @property {boolean} keepOldPages - If true, pages will not be cleared when defaultPageCallback is called.
+ */
+/**
+ * The objects by pk.
+ *
+ * @typedef {{[pk: string]: ListObject}} ObjectsByPk
+ */
+/**
+ * The objects in order, based on .order & .objects.
+ *
+ * @typedef {import('vue').ComputedRef<ListObject[]>} ObjectsInOrder
+ */
+/**
+ * The order of the objects in the list.
+ *
+ * @typedef {import('vue').ComputedRef<string[]>} ListOrder
+ */
+/**
+ * The raw state object for the list instance, defining the reactive properties and their types.
+ *
+ * @typedef {object} ListInstanceRawState
+ * @property {object} crud - CRUD functions and their configurations for the list.
+ * @property {object} crud.args - Arguments for the CRUD functions.
+ * @property {Function} [crud.list] - Function to list objects.
+ * @property {string} pkKey - The primary key field for the list objects.
+ * @property {object} retrieveArgs - Arguments passed to the server for retrieval operations.
+ * @property {object} listArgs - Arguments passed to the server for listing operations.
+ * @property {ObjectsByPk} objects - The list objects stored by their pks.
+ * @property {boolean} running - Indicates if there are ongoing reactive updates.
+ * @property {Readonly<import('vue').Ref<boolean>>} [loading] - Indicates if the list is currently loading.
+ * @property {Readonly<import('vue').Ref<boolean>>} errored - Indicates if an error occurred during the last operation.
+ * @property {Readonly<import('vue').Ref<Error|null>>} error - The last error encountered.
+ * @property {ListOrder} order - The order of objects in the list.
+ * @property {ObjectsInOrder} objectsInOrder - The objects in the order specified by the list.
+ */
+/**
+ * Defines the reactive state used by the list instance.
+ *
+ * @typedef {import('vue').UnwrapNestedRefs<ListInstanceRawState>} ListInstanceState
+ */
+/**
+ * Defines the methods provided by the list instance for managing objects in the list.
+ *
+ * @typedef {object} ListInstanceFunctions
+ * @property {(newObjects: ListObject[]) => void} defaultPageCallback - Handles new or updated objects, respecting the keepOldPages setting.
+ * @property {(newObjects: ListObject[]) => void} pageCallback - Customizable callback for handling new objects per page.
+ * @property {(object: ListObject) => void} addListObject - Adds an object to the list.
+ * @property {(object: ListObject) => void} updateListObject - Updates an object in the list.
+ * @property {(objectId: string) => void} deleteListObject - Deletes an object from the list by pk.
+ * @property {() => void} clearList - Clears all objects and errors from the list.
+ * @property {() => string} getFakePk - Generates a unique fake pk for use within the list.
+ * @property {() => Promise<boolean>} list - Initiates a fetch to retrieve objects according to the CRUD configuration, returning a promise to a boolean indicating success.
+ * @property {() => Promise<boolean>} bulkDelete - Initiates a bulk delete operation on all objects in the list, returning a promise to a boolean indicating success.
+ * @property {() => Promise<object|string|false>} executeAction - Initiates an action on all objects in the list, returning the response, or false if the action failed.
+ */
+/**
+ * Helper type to facilitate the combination of state and functions into a single type.
+ *
+ * @typedef {{state: ListInstanceState}} ListInstanceStateMixIn
+ */
+/**
+ * The list instance, combining state management and functional operations for managing a list of objects.
+ *
+ * @typedef {ListInstanceStateMixIn & ListInstanceFunctions} ListInstance
+ */
+/**
+ * Creates and manages multiple list instances.
+ *
+ * @param {{[key: string]: ListInstanceOptions}} listInstanceArgs - The arguments for each list instance.
+ * @returns {{[key: string]: ListInstance}} An object of list instances.
+ */
+export function useListInstances(listInstanceArgs: {
+    [key: string]: ListInstanceOptions;
+}): {
+    [key: string]: ListInstance;
+};
+/**
+ * Creates and manages a reactive list of objects, providing utilities to add, update, delete, and fetch objects
+ *  according to the specified CRUD operations.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useListInstance } from "@arrai-innovations/reactive-helpers";
+ * import { reactive, toRef } from "vue";
+ *
+ * const props = defineProps({
+ *     // whatever props are required for your configured list instance
+ *     someListFilter: {
+ *         type: string,
+ *         default: "",
+ *     },
+ * });
+ *
+ * const listInstanceProps = reactive({
+ *     crudArgs: {
+ *         // whatever arguments are required for your configured list crud function to get the right endpoint
+ *     },
+ *     listArgs: {
+ *         // whatever arguments are required for your configured list function to get the right list
+ *         someListFilter: toRef(props, "someListFilter"),
+ *     },
+ *     retrieveArgs: {
+ *         // whatever arguments are required for your configured list function to get items back looking as expected
+ *     },
+ * });
+ * const listInstance = useListInstance({ props: listInstanceProps });
+ * watch(toRef(props, "someListFilter"), (newValue, oldValue) => {
+ *     if (newValue !== oldValue && !isEmpty(newValue)) {
+ *         listInstance.list();
+ *     }
+ * }, {
+ *    immediate: true,
+ *    deep: true,
+ * });
+ * </script>
+ * <template>
+ *     <ul>
+ *         <!-- reactive list of objects, re-retrieving the list as someListFilter changes. -->
+ *         <li v-for="obj in listInstance.state.objectsInOrder">
+ *             {{ obj }}
+ *         </li>
+ *     </ul>
+ * </template>
+ * ```
+ *
+ * @param {ListInstanceOptions} options - Specifies the configuration options for creating a list instance, including
+ *  properties for CRUD operations and UI behaviors like page persistence.
+ * @returns {ListInstance} The list instance.
+ * @throws {ListInstanceError} If the props or keepOldPages are missing.
+ */
+export function useListInstance({ props, functions, keepOldPages }: ListInstanceOptions): ListInstance;
+/**
+ * A composable function for managing a list of objects.
+ *
+ * @module use/listInstance.js
+ */
+/**
+ * Defines the structure for the objects stored within the list, each identified by a unique pk and capable of
+ *  holding various key-value pairs.
+ *
+ * @typedef {{pk: string, [key: string]: any}} ListObject
+ */
+/**
+ * Defines a custom error class specific to list instance operations, encapsulating details about errors that occur
+ *  during list manipulation and processing.
+ */
+export class ListInstanceError extends Error {
+    /**
+     * Creates an instance of ListInstanceError.
+     *
+     * @param {string} message - The error message.
+     * @param {string} code - The error code.
+     */
+    constructor(message: string, code: string);
+    code: string;
+}
+/**
+ * The reactive arguments for the list instance.
+ */
+export type ListInstanceProps = {
+    /**
+     * - The primary key field for the list objects.
+     */
+    pkKey: string;
+    /**
+     * - The arguments passed to the server.
+     */
+    retrieveArgs: object;
+    /**
+     * - The arguments passed to the server.
+     */
+    listArgs: object;
+    /**
+     * - Implementation specific arguments.
+     */
+    crudArgs: object;
+};
+/**
+ * The configuration options used to create a list instance.
+ */
+export type ListInstanceOptions = {
+    /**
+     * - The props for the list instance.
+     */
+    props: import("vue").UnwrapNestedRefs<ListInstanceProps>;
+    /**
+     * - Default implementation are used as set by `setListCrud`.
+     */
+    functions?: {
+        list?: import("../config/listCrud.js").ListFn;
+        bulkDelete?: import("../config/listCrud.js").BulkDeleteFn;
+        executeAction?: import("../config/listCrud.js").ExecuteActionFn;
+        subscribe?: import("../config/listCrud.js").SubscribeFn;
+    };
+    /**
+     * - If true, pages will not be cleared when defaultPageCallback is called.
+     */
+    keepOldPages: boolean;
+};
+/**
+ * The objects by pk.
+ */
+export type ObjectsByPk = {
+    [pk: string]: ListObject;
+};
+/**
+ * The objects in order, based on .order & .objects.
+ */
+export type ObjectsInOrder = import("vue").ComputedRef<ListObject[]>;
+/**
+ * The order of the objects in the list.
+ */
+export type ListOrder = import("vue").ComputedRef<string[]>;
+/**
+ * The raw state object for the list instance, defining the reactive properties and their types.
+ */
+export type ListInstanceRawState = {
+    /**
+     * - CRUD functions and their configurations for the list.
+     */
+    crud: {
+        args: object;
+        list?: Function;
+    };
+    /**
+     * - The primary key field for the list objects.
+     */
+    pkKey: string;
+    /**
+     * - Arguments passed to the server for retrieval operations.
+     */
+    retrieveArgs: object;
+    /**
+     * - Arguments passed to the server for listing operations.
+     */
+    listArgs: object;
+    /**
+     * - The list objects stored by their pks.
+     */
+    objects: ObjectsByPk;
+    /**
+     * - Indicates if there are ongoing reactive updates.
+     */
+    running: boolean;
+    /**
+     * - Indicates if the list is currently loading.
+     */
+    loading?: Readonly<import("vue").Ref<boolean>>;
+    /**
+     * - Indicates if an error occurred during the last operation.
+     */
+    errored: Readonly<import("vue").Ref<boolean>>;
+    /**
+     * - The last error encountered.
+     */
+    error: Readonly<import("vue").Ref<Error | null>>;
+    /**
+     * - The order of objects in the list.
+     */
+    order: ListOrder;
+    /**
+     * - The objects in the order specified by the list.
+     */
+    objectsInOrder: ObjectsInOrder;
+};
+/**
+ * Defines the reactive state used by the list instance.
+ */
+export type ListInstanceState = import("vue").UnwrapNestedRefs<ListInstanceRawState>;
+/**
+ * Defines the methods provided by the list instance for managing objects in the list.
+ */
+export type ListInstanceFunctions = {
+    /**
+     * - Handles new or updated objects, respecting the keepOldPages setting.
+     */
+    defaultPageCallback: (newObjects: ListObject[]) => void;
+    /**
+     * - Customizable callback for handling new objects per page.
+     */
+    pageCallback: (newObjects: ListObject[]) => void;
+    /**
+     * - Adds an object to the list.
+     */
+    addListObject: (object: ListObject) => void;
+    /**
+     * - Updates an object in the list.
+     */
+    updateListObject: (object: ListObject) => void;
+    /**
+     * - Deletes an object from the list by pk.
+     */
+    deleteListObject: (objectId: string) => void;
+    /**
+     * - Clears all objects and errors from the list.
+     */
+    clearList: () => void;
+    /**
+     * - Generates a unique fake pk for use within the list.
+     */
+    getFakePk: () => string;
+    /**
+     * - Initiates a fetch to retrieve objects according to the CRUD configuration, returning a promise to a boolean indicating success.
+     */
+    list: () => Promise<boolean>;
+    /**
+     * - Initiates a bulk delete operation on all objects in the list, returning a promise to a boolean indicating success.
+     */
+    bulkDelete: () => Promise<boolean>;
+    /**
+     * - Initiates an action on all objects in the list, returning the response, or false if the action failed.
+     */
+    executeAction: () => Promise<object | string | false>;
+};
+/**
+ * Helper type to facilitate the combination of state and functions into a single type.
+ */
+export type ListInstanceStateMixIn = {
+    state: ListInstanceState;
+};
+/**
+ * The list instance, combining state management and functional operations for managing a list of objects.
+ */
+export type ListInstance = ListInstanceStateMixIn & ListInstanceFunctions;
+/**
+ * Defines the structure for the objects stored within the list, each identified by a unique pk and capable of
+ *  holding various key-value pairs.
+ */
+export type ListObject = {
+    pk: string;
+    [key: string]: any;
+};
+//# sourceMappingURL=listInstance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"listInstance.d.ts","sourceRoot":"","sources":["../../use/listInstance.js"],"names":[],"mappings":"AAsCA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;GAeG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;GAKG;AACH,mDAHW;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAAA;CAAC,GAClC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;CAAC,CASzC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,oEALW,mBAAmB,GAEjB,YAAY,CAwTxB;AA5fD;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;GAGG;AACH;IACI;;;;;OAKG;IACH,qBAHW,MAAM,QACN,MAAM,EAMhB;IADG,aAAgB;CAEvB;;;;;;;;WAMa,MAAM;;;;kBACN,MAAM;;;;cACN,MAAM;;;;cACN,MAAM;;;;;;;;;WAON,OAAO,KAAK,EAAE,gBAAgB,CAAC,iBAAiB,CAAC;;;;gBAE5D;QAA8D,IAAI,GAAvD,OAAO,uBAAuB,EAAE,MAAM;QAEoB,UAAU,GAAnE,OAAO,uBAAuB,EAAE,YAAY;QAEiB,aAAa,GAAzE,OAAO,uBAAuB,EAAE,eAAe;QAEO,SAAS,GAAjE,OAAO,uBAAuB,EAAE,WAAW;KAEtD;;;;kBAAW,OAAO;;;;;0BAMR;IAAC,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,CAAA;CAAC;;;;6BAM1B,OAAO,KAAK,EAAE,WAAW,CAAC,UAAU,EAAE,CAAC;;;;wBAMvC,OAAO,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,CAAC;;;;;;;;UAQ7C;QAAwB,IAAI,EAAjB,MAAM;QACU,IAAI;KAC/B;;;;WAAW,MAAM;;;;kBACN,MAAM;;;;cACN,MAAM;;;;aACN,WAAW;;;;aACX,OAAO;;;;cACP,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;;;;WACvC,SAAS;;;;oBACT,cAAc;;;;;gCAMf,OAAO,KAAK,EAAE,gBAAgB,CAAC,oBAAoB,CAAC;;;;;;;;yBAOnD,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,IAAI;;;;kBAClC,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,IAAI;;;;mBAClC,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI;;;;sBAC5B,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI;;;;sBAC5B,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI;;;;eAC1B,MAAM,IAAI;;;;eACV,MAAM,MAAM;;;;UACZ,MAAM,OAAO,CAAC,OAAO,CAAC;;;;gBACtB,MAAM,OAAO,CAAC,OAAO,CAAC;;;;mBACtB,MAAM,OAAO,CAAC,MAAM,GAAC,MAAM,GAAC,KAAK,CAAC;;;;;qCAMnC;IAAC,KAAK,EAAE,iBAAiB,CAAA;CAAC;;;;2BAM1B,sBAAsB,GAAG,qBAAqB;;;;;yBApH9C;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC"}

package/types/use/listKeys.d.ts

@@ -0,0 +1,15 @@
+export const listInstanceStateKeys: string[];
+export const listInstanceFunctions: string[];
+export const listSubscriptionStateKeys: string[];
+export const listSubscriptionFunctions: string[];
+export const listRelatedStateKeys: string[];
+export const listRelatedFunctions: any[];
+export const listCalculatedStateKeys: string[];
+export const listCalculatedFunctions: any[];
+export const listFilterStateKeys: string[];
+export const listFilterFunctions: any[];
+export const listSearchStateKeys: string[];
+export const listSearchFunctions: any[];
+export const listSortStateKeys: string[];
+export const listSortFunctions: any[];
+//# sourceMappingURL=listKeys.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"listKeys.d.ts","sourceRoot":"","sources":["../../use/listKeys.js"],"names":[],"mappings":"AAAA,6CAiBE;AACF,6CAYE;AAEF,iDAOE;AACF,iDAAoF;AAEpF,4CAQE;AACF,yCAAuC;AAEvC,+CAME;AACF,4CAA0C;AAE1C,2CAWE;AACF,wCAAsC;AAEtC,2CAcE;AACF,wCAAsC;AACtC,yCAWE;AACF,sCAAoC"}