@arrai-innovations/reactive-helpers 18.0.1 → 18.0.2

package/types/use/listRelated.d.ts

@@ -0,0 +1,239 @@
+/**
+ * The options for the list related composition function.
+ *
+ * @typedef {object} ListRelatedOptions
+ * @property {ListRelatedParentState} parentState - The parent state object.
+ * @property {import('vue').Ref<ListRelatedRules>} relatedObjectsRules - The rules for the related objects.
+ */
+/**
+ * The properties for the list related composition function.
+ *
+ * @typedef {object} ListRelatedProperties
+ * @property {ListRelatedState} state - The state for the list related property.
+ * @property {ListRelatedParentState} parentState - The parent state object.
+ * @property {import('./watchesRunning.js').WatchesRunning} watchesRunning - The watches running instance.
+ * @property {import('vue').EffectScope} effectScope - The effect scope for the list related property.
+ */
+/**
+ * An instance of `useListRelated`.
+ *
+ * @typedef {ListRelatedProperties} ListRelated
+ */
+/**
+ * Creates and manages multiple instances of list-related properties, linking each to corresponding parent instances
+ * based on provided configuration.
+ *
+ * @param {{
+ *     [key: string]: ListRelatedOptions
+ * }} listRelatedArgs - The options for the list related properties.
+ * @returns {{[key: string]: ListRelated}} - The instances of the list related properties.
+ */
+export function useListRelateds(listRelatedArgs: {
+    [key: string]: ListRelatedOptions;
+}): {
+    [key: string]: ListRelated;
+};
+/**
+ * Initializes and returns an instance of a related objects manager. This function sets up reactive states
+ * and computations that dynamically adjust as the parent list's state changes. It uses defined rules
+ * for object relationships to compute and update related objects in real-time, ensuring that changes in the parent
+ * state are reflected in the relationships defined by the rules.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useListInstance, useListRelated } from "@arrai-innovations/reactive-helpers";
+ * import { reactive, toRef } from "vue";
+ *
+ * const props = defineProps({
+ *     someListFilter: {
+ *         type: String,
+ *         default: "",
+ *         description: "The filter to apply to the list.",
+ *     },
+ *     objects: {
+ *         type: Object,
+ *         default: () => ({}),
+ *         description: "The objects to relate to.",
+ *     },
+ *     order: {
+ *          type: Array,
+ *          default: () => [],
+ *          description: "The order of the list.",
+ *     },
+ * });
+ *
+ * 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"),
+ *     },
+ *     pkKey: 'id',
+ *     retrieveArgs: {
+ *         // whatever arguments are required for your configured list function to get items back looking as expected
+ *     },
+ *     intendToList: false,
+ * });
+ * listInstanceProps.intendToList = computed(()=> !!props.someListFilter);
+ * const listInstance = useListInstance({ props: listInstanceProps });
+ * const listRelatedProps = reactive({
+ *     parentState: listInstance.state, // reactive-to-reactive so no need for toRef
+ *     relatedObjectsRules: {
+ *         someRule: {
+ *             // this can point to a key or an array of keys to relate to
+ *             pkKey: "dot.separated.key.to.pk.on.an.listInstance.object",
+ *             objects: toRef(props, "objects"),
+ *             order: toRef(props, "order"),
+ *         },
+ *     },
+ * });
+ * const listRelated = useListRelated(listRelatedProps);
+ * </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 related object or objects based on the rule -->
+ *                 {{ listRelated.state.relatedObjects[obj.id].someRule }}
+ *             </div>
+ *         </li>
+ *     </ul>
+ * </template>
+ * ```
+ *
+ * @param {ListRelatedOptions} options -  The configuration options including the parent state and rules for related
+ *  objects.
+ * @returns {ListRelated} - A reactive instance that manages related objects, providing real-time updates and
+ * maintaining the integrity of object relationships as per the specified rules.
+ */
+export function useListRelated({ parentState, relatedObjectsRules }: ListRelatedOptions): ListRelated;
+/**
+ * The options for the list related composition function.
+ */
+export type ListRelatedOptions = {
+    /**
+     * - The parent state object.
+     */
+    parentState: ListRelatedParentState;
+    /**
+     * - The rules for the related objects.
+     */
+    relatedObjectsRules: import("vue").Ref<ListRelatedRules>;
+};
+/**
+ * The properties for the list related composition function.
+ */
+export type ListRelatedProperties = {
+    /**
+     * - The state for the list related property.
+     */
+    state: ListRelatedState;
+    /**
+     * - The parent state object.
+     */
+    parentState: ListRelatedParentState;
+    /**
+     * - The watches running instance.
+     */
+    watchesRunning: import("./watchesRunning.js").WatchesRunning;
+    /**
+     * - The effect scope for the list related property.
+     */
+    effectScope: import("vue").EffectScope;
+};
+/**
+ * An instance of `useListRelated`.
+ */
+export type ListRelated = ListRelatedProperties;
+/**
+ * The rule for defining relationships for objects in a list.
+ */
+export type ListRelatedRule = {
+    /**
+     * - Specifies the foreign key used to link objects across lists. Planned to be renamed to
+     * 'fkKey' to better reflect its usage.
+     */
+    pkKey: string;
+    /**
+     * - Specifies the order in which related objects should be sorted, if applicable.
+     */
+    order?: string[];
+    /**
+     * - The objects that can be related based on the foreign key.
+     */
+    objects: import("./listInstance.js").ObjectsByPk;
+};
+/**
+ * The rules for defining relationships among objects in a list.
+ */
+export type ListRelatedRules = import("vue").UnwrapNestedRefs<{
+    [rule: string]: ListRelatedRule;
+}>;
+/**
+ * Represents the internal state used by the list related composition function. It manages and computes the relationships
+ * between objects based on specified rules, providing real-time updates to related objects as the parent state changes.
+ */
+export type ListRelatedRawState = {
+    /**
+     * - Stores computed references to related objects, allowing for dynamic access based on object pk and specific rules.
+     */
+    relatedObjects: {
+        [pk: string]: {
+            [rule: string]: import("vue").ComputedRef<any>;
+        };
+    };
+    /**
+     * - Defines the rules for establishing relationships, such as foreign key links and sorting orders.
+     */
+    relatedObjectsRules: ListRelatedRules;
+    /**
+     * - Maps each object pk and rule to a tuple consisting of the related object and its respective key, facilitating direct data manipulation.
+     */
+    objAndKeyForPkAndRule: {
+        [pk: string]: {
+            [rule: string]: import("vue").ComputedRef<[object, string]>;
+        };
+    };
+    /**
+     * - Maintains computed references to the foreign keys for each object pk and rule, crucial for navigating complex data relationships.
+     */
+    fkForPkAndRule: {
+        [pk: string]: {
+            [rule: string]: import("vue").ComputedRef<any>;
+        };
+    };
+    /**
+     * - Flags whether the watch on parent state objects is currently active, ensuring updates trigger as needed.
+     */
+    relatedObjectsParentStateObjectsWatchRunning: boolean;
+    /**
+     * - Indicates if watches on the related objects themselves are active, managing updates efficiently.
+     */
+    relatedObjectsWatchRunning: boolean;
+    /**
+     * - Signals whether any computations related to object relationships are currently in progress.
+     */
+    relatedRunning: boolean;
+    /**
+     * - General flag that indicates if the list-related logic is processing, used to manage UI feedback or prevent concurrent operations.
+     */
+    running: import("vue").Ref<boolean>;
+};
+/**
+ * The raw state properties for a parent of a list related property.
+ */
+export type ListRelatedParentRawState = (import("./listInstance.js").ListInstanceRawState & Partial<import("./listSubscription.js").ListSubscriptionRawState>);
+/**
+ * The type for a parentState object.
+ */
+export type ListRelatedParentState = import("vue").UnwrapNestedRefs<ListRelatedParentRawState>;
+/**
+ * The state for a list related property.
+ */
+export type ListRelatedState = import("vue").UnwrapNestedRefs<ListRelatedParentRawState & ListRelatedRawState>;
+//# sourceMappingURL=listRelated.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"listRelated.d.ts","sourceRoot":"","sources":["../../use/listRelated.js"],"names":[],"mappings":"AA+GA;;;;;;GAMG;AAEH;;;;;;;;GAQG;AAIH;;;;GAIG;AAEH;;;;;;;;GAQG;AACH,iDALW;IACV,CAAO,GAAG,EAAE,MAAM,GAAG,kBAAkB,CAAA;CACpC,GACS;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAA;CAAC,CASxC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AACH,qEALW,kBAAkB,GAEhB,WAAW,CAmLvB;;;;;;;;iBAtSa,sBAAsB;;;;yBACtB,OAAO,KAAK,EAAE,GAAG,CAAC,gBAAgB,CAAC;;;;;;;;;WAOnC,gBAAgB;;;;iBAChB,sBAAsB;;;;oBACtB,OAAO,qBAAqB,EAAE,cAAc;;;;iBAC5C,OAAO,KAAK,EAAE,WAAW;;;;;0BAQ1B,qBAAqB;;;;;;;;;WApGpB,MAAM;;;;YAEN,MAAM,EAAE;;;;aACR,OAAO,mBAAmB,EAAE,WAAW;;;;;+BAMxC,OAAO,KAAK,EAAE,gBAAgB,CAAC;IAC3C,CAAO,IAAI,EAAE,MAAM,GAAG,eAAe,CAAC;CACnC,CAAC;;;;;;;;;oBAQS;QACb,CAAO,EAAE,EAAE,MAAM,GAAG;YACpB,CAAW,IAAI,EAAE,MAAM,GAAG,OAAO,KAAK,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;SAClD,CAAC;KACL;;;;yBACU,gBAAgB;;;;2BAChB;QACb,CAAO,EAAE,EAAE,MAAM,GAAG;YACpB,CAAW,IAAI,EAAE,MAAM,GAAG,OAAO,KAAK,EAAE,WAAW,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;SAC/D,CAAC;KACL;;;;oBACU;QACb,CAAO,EAAE,EAAE,MAAM,GAAG;YACpB,CAAW,IAAI,EAAE,MAAM,GAAG,OAAO,KAAK,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;SAClD,CAAC;KACL;;;;kDACU,OAAO;;;;gCACP,OAAO;;;;oBACP,OAAO;;;;aACP,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC;;;;;wCAM3B,CACZ,OAAa,mBAAmB,EAAE,oBAAoB,GAChD,OAAO,CAAC,OAAO,uBAAuB,EAAE,wBAAwB,CAAC,CACpE;;;;qCAMS,OAAO,KAAK,EAAE,gBAAgB,CAAC,yBAAyB,CAAC;;;;+BAMzD,OAAO,KAAK,EAAE,gBAAgB,CACpC,yBAAyB,GACzB,mBAAmB,CACtB"}

package/types/use/listSearch.d.ts

@@ -0,0 +1,298 @@
+/**
+ * Represents the raw reactive state used by the list search functionality.
+ *
+ * @typedef {object} ListSearchRawState
+ * @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.
+ * @property {object} textSearchRules - Rules defining how text search should be applied on list items. Each rule
+ *  specifies a key and a function to extract the searchable text.
+ * @property {string} textSearchValue - The current value used for searching.
+ * @property {object} objectIndexes - Indexes built for quick search across objects based on rules.
+ * @property {object} customDocumentOptions - Configuration options for the search document, used by FlexSearch.
+ * @property {object} customSearchOptions - Additional search options for FlexSearch.
+ * @property {boolean} searched - Flag indicating if a search has been performed.
+ * @property {boolean} running - Indicates if the search process is actively running.
+ */
+/**
+ *
+ *
+ * @typedef {(
+ *     import('./listInstance.js').ListInstanceRawState &
+ *     Partial<import('./listSubscription.js').ListSubscriptionRawState> &
+ *     Partial<import('./listRelated.js').ListRelatedRawState> &
+ *     Partial<import('./listCalculated.js').ListCalculatedRawState> &
+ *     Partial<import('./listFilter.js').ListFilterRawState>
+ * )} ListSearchParentRawState
+ */
+/**
+ * @typedef {import('vue').UnwrapNestedRefs<ListSearchParentRawState>} ListSearchParentState - The parent state for a list search.
+ */
+/**
+ * @typedef {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
+ * >} ListSearchState - The state for a list search.
+ */
+/**
+ * @typedef {object} ListSearchRawProps - The raw props for a list search.
+ * @property {Array} 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.
+ * @property {object} customSearchOptions - FlexSearch.Search options.
+ * @property {object} [customSearchOptions.limit=1000] - FlexSearch.Search options.
+ */
+/**
+ * @typedef {object} ListSearchOptions - The options for a list search.
+ * @property {ListSearchParentState} parentState - The parent state.
+ * @property {import('vue').UnwrapNestedRefs<ListSearchRawProps>} props - The props.
+ * @property {number} [throttle=500] - The throttle.
+ * @property {boolean} [showAllWhenEmpty=true] - Whether to show all items when the search is empty.
+ */
+/**
+ * The properties on a list search instance.
+ *
+ * @typedef {object} ListSearchProperties
+ * @property {ListSearchState} state - The state.
+ * @property {import('vue').EffectScope} effectScope - The effect scope.
+ * @property {import('./search.js').SearchInstance} textSearchIndex - The text search index.
+ */
+/**
+ * The provided list search instance, containing properties and functions.
+ *
+ * @typedef {ListSearchProperties} ListSearch
+ */
+/**
+ * Helper function that initializes multiple list search instances from given configurations. This is typically used
+ * when multiple list components require individual search capabilities.
+ *
+ * @param {{
+ *     [key: string]: ListSearchOptions
+ * }} listSearchArgs - Configuration arguments for each search instance, including state and props.
+ * @returns {{
+ *    [key: string]: ListSearch
+ * }} - A collection of initialized list search instances.
+ */
+export function useListSearches(listSearchArgs: {
+    [key: string]: ListSearchOptions;
+}): {
+    [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 {object} ListSearchProps
+ * @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.
+ * @property {object} customSearchOptions - FlexSearch.Search options.
+ * @property {object} [customSearchOptions.limit=1000] - FlexSearch.Search options.
+ */
+/**
+ * @typedef {object} ListSearchInstanceOptions
+ * @property {object} parentState - The list being filtered.
+ * @property {ListSearchProps} props - Reactive properties.
+ * @property {number} [throttle=500] - Throttle wait time.
+ * @property {boolean} [showAllWhenEmpty=true] - Whether to show all items when the search is empty.
+ */
+/**
+ * Creates a search functionality instance for a list, configuring reactive state and dependencies to
+ * dynamically update visible items based on provided search criteria and rules.
+ *
+ * @example
+ * ```vue
+ * import { reactive, defineProps, toRef } from 'vue';
+ * import { useListInstance, useListSearch } from '@arrai-innovations/reactive-helpers';
+ *
+ * const props = defineProps({
+ *     searchQuery: String
+ * });
+ * const listInstance = useListInstance({ props });
+ * const searchProps = reactive({
+ *     textSearchRules: [{ key: 'name', fn: item => item.name }],
+ *     textSearchValue: toRef(props, 'searchQuery')
+ * });
+ * const listSearch = useListSearch({
+ *     parentState: listInstance.state,
+ *     props: searchProps
+ * });
+ * // listSearch.state.objects will contain the filtered items from listInstance.state.objects
+ * // listSearch.state.searched will be true if a search has been performed
+ * ```
+ *
+ * @param {ListSearchInstanceOptions} options - Configuration for initializing the list search.
+ * @returns {ListSearch} The initialized list search instance with reactive state and utilities for search management.
+ */
+export function useListSearch({ parentState, props, throttle, showAllWhenEmpty }: ListSearchInstanceOptions): ListSearch;
+/**
+ * Represents the raw reactive state used by the list search functionality.
+ */
+export type ListSearchRawState = {
+    /**
+     * - Currently filtered objects based on the search.
+     */
+    objects: import("./listInstance.js").ObjectsByPk;
+    /**
+     * - 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.
+     */
+    order: import("./listInstance.js").ListOrder;
+    /**
+     * - 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.
+     */
+    textSearchValue: string;
+    /**
+     * - Indexes built for quick search across objects based on rules.
+     */
+    objectIndexes: object;
+    /**
+     * - Configuration options for the search document, used by FlexSearch.
+     */
+    customDocumentOptions: object;
+    /**
+     * - Additional search options for FlexSearch.
+     */
+    customSearchOptions: object;
+    /**
+     * - Flag indicating if a search has been performed.
+     */
+    searched: boolean;
+    /**
+     * - Indicates if the search process is actively running.
+     */
+    running: boolean;
+};
+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.
+ */
+export type ListSearchParentState = import("vue").UnwrapNestedRefs<ListSearchParentRawState>;
+/**
+ * - 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.
+ */
+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.
+     */
+    textSearchRules: any[];
+    /**
+     * - The value to search for.
+     */
+    textSearchValue: string;
+    /**
+     * - FlexSearch.Document options.
+     */
+    customDocumentOptions: object;
+    /**
+     * - FlexSearch.Search options.
+     */
+    customSearchOptions: {
+        limit?: object;
+    };
+};
+/**
+ * - The options for a list search.
+ */
+export type ListSearchOptions = {
+    /**
+     * - The parent state.
+     */
+    parentState: ListSearchParentState;
+    /**
+     * - The props.
+     */
+    props: import("vue").UnwrapNestedRefs<ListSearchRawProps>;
+    /**
+     * - The throttle.
+     */
+    throttle?: number;
+    /**
+     * - Whether to show all items when the search is empty.
+     */
+    showAllWhenEmpty?: boolean;
+};
+/**
+ * The properties on a list search instance.
+ */
+export type ListSearchProperties = {
+    /**
+     * - The state.
+     */
+    state: ListSearchState;
+    /**
+     * - The effect scope.
+     */
+    effectScope: import("vue").EffectScope;
+    /**
+     * - The text search index.
+     */
+    textSearchIndex: import("./search.js").SearchInstance;
+};
+/**
+ * The provided list search instance, containing properties and functions.
+ */
+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.
+ */
+export type TextSearchRules = string | string[] | object[];
+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.
+     */
+    textSearchRules: TextSearchRules;
+    /**
+     * - The value to search for.
+     */
+    textSearchValue: string;
+    /**
+     * - FlexSearch.Document options.
+     */
+    customDocumentOptions: object;
+    /**
+     * - FlexSearch.Search options.
+     */
+    customSearchOptions: {
+        limit?: object;
+    };
+};
+export type ListSearchInstanceOptions = {
+    /**
+     * - The list being filtered.
+     */
+    parentState: object;
+    /**
+     * - Reactive properties.
+     */
+    props: ListSearchProps;
+    /**
+     * - Throttle wait time.
+     */
+    throttle?: number;
+    /**
+     * - Whether to show all items when the search is empty.
+     */
+    showAllWhenEmpty?: boolean;
+};
+//# sourceMappingURL=listSearch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"listSearch.d.ts","sourceRoot":"","sources":["../../use/listSearch.js"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;GAUG;AAEH;;GAEG;AAEH;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH;;;;;;;GAOG;AAIH;;;;GAIG;AAEH;;;;;;;;;;GAUG;AACH,gDAPW;IACV,CAAO,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAAA;CACnC,GACS;IACZ,CAAM,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;CAC3B,CASH;AAED;;;;;GAKG;AAEH;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,kFAHW,yBAAyB,GACvB,UAAU,CAqStB;;;;;;;;aArba,OAAO,mBAAmB,EAAE,WAAW;;;;oBACvC,OAAO,mBAAmB,EAAE,cAAc;;;;WAC1C,OAAO,mBAAmB,EAAE,SAAS;;;;;qBACrC,MAAM;;;;qBAEN,MAAM;;;;mBACN,MAAM;;;;2BACN,MAAM;;;;yBACN,MAAM;;;;cACN,OAAO;;;;aACP,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,GAC7D,OAAO,CAAC,OAAO,iBAAiB,EAAE,kBAAkB,CAAC,CACxD;;;;oCAIS,OAAO,KAAK,EAAE,gBAAgB,CAAC,wBAAwB,CAAC;;;;8BAIxD,OAAO,KAAK,EAAE,gBAAgB,CACpC,kBAAkB,GAClB,OAAO,CAAC,OAAO,iBAAiB,EAAE,kBAAkB,CAAC,GACrD,OAAO,CAAC,OAAO,qBAAqB,EAAE,sBAAsB,CAAC,GAC7D,OAAO,CAAC,OAAO,kBAAkB,EAAE,mBAAmB,CAAC,GACvD,OAAO,CAAC,OAAO,uBAAuB,EAAE,wBAAwB,CAAC,GACvE,OAAa,mBAAmB,EAAE,oBAAoB,CACnD;;;;;;;;;;;;qBAMU,MAAM;;;;2BACN,MAAM;;;;yBAEjB;QAAwC,KAAK,GAAlC,MAAM;KACnB;;;;;;;;;iBAIa,qBAAqB;;;;WACrB,OAAO,KAAK,EAAE,gBAAgB,CAAC,kBAAkB,CAAC;;;;eAClD,MAAM;;;;uBACN,OAAO;;;;;;;;;WAOP,eAAe;;;;iBACf,OAAO,KAAK,EAAE,WAAW;;;;qBACzB,OAAO,aAAa,EAAE,cAAc;;;;;yBAQrC,oBAAoB;;;;;8BA2BpB,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE;;;;;qBAK3B,eAAe;;;;qBACf,MAAM;;;;2BACN,MAAM;;;;yBAEjB;QAAwC,KAAK,GAAlC,MAAM;KACnB;;;;;;iBAIa,MAAM;;;;WACN,eAAe;;;;eACf,MAAM;;;;uBACN,OAAO"}