@envive-ai/react-hooks 0.2.3 → 0.2.5

package/dist/hooks/UpdateAnalyticsProps/index.js

@@ -0,0 +1,60 @@
+import "../../types-CtUb63bt.js";
+import "../../events-DyUix-Bn.js";
+import "../../models-c86hYW-F.js";
+import "../../featureGates-KEwAL8p_.js";
+import "../../urlsParser-DxjoLj98.js";
+import "../../graphql-3PxNRFOc.js";
+import "../../utils-DIvMgPe8.js";
+import "../../api-BWSsazAG.js";
+import "../../logger-W3lqg-4b.js";
+import "../../utilityTypes-B2KuRn37.js";
+import "../../variantInfo-BfKlkaWU.js";
+import "../../localStorageContext-BPZ82q-G.js";
+import "../../enviveConfig-DZBohDpc.js";
+import "../../graphqlConfig-mDg6J44N.js";
+import { SpiffyMetricsEventName, hasParsedVariantInfoAtom, useAmplitude, variantInfoAtom } from "../../utils-jYtD3hmA.js";
+import "../../atomStore-DXTVqiKc.js";
+import "../../enviveConfigContext-DrDjCems.js";
+import "../../featureFlagServiceContext-FBM6DdMJ.js";
+import "../../domObserver-v9ODTyfT.js";
+import { useEffect, useRef } from "react";
+import { useAtomValue } from "jotai";
+
+//#region src/hooks/UpdateAnalyticsProps/useUpdateAnalyticsProps.ts
+/**
+* Updates the default analytics properties whenever the variant info changes. This hook also
+* triggers any events that should be sent once per page visit.
+*/
+const useUpdateAnalyticsProps = () => {
+	const variantInfo = useAtomValue(variantInfoAtom);
+	const hasInitialized = useRef(false);
+	const hasParsedVariantInfo = useAtomValue(hasParsedVariantInfoAtom);
+	const { trackEvent, setSupplementalDefaultProps } = useAmplitude();
+	useEffect(() => {
+		const variantInfoWithPrefix = Object.fromEntries(Object.entries(variantInfo).map(([key, value]) => [`variantInfo.${key}`, value]));
+		const defaultEventProperties = {
+			page_variant: variantInfo.variant,
+			...variantInfoWithPrefix
+		};
+		if (variantInfo.variant === "pdp") defaultEventProperties.product_id = variantInfo.productId;
+		if (variantInfo.variant === "plp") defaultEventProperties.plp_id = variantInfo.plpId;
+		if (variantInfo.variant === "page_visit") {
+			defaultEventProperties.page_visit_category = variantInfo.pageVisitCategory;
+			defaultEventProperties.page_visit_url = variantInfo.url;
+		}
+		setSupplementalDefaultProps(defaultEventProperties);
+		if (!hasInitialized.current && hasParsedVariantInfo) {
+			trackEvent({ eventName: SpiffyMetricsEventName.BundleLoaded });
+			hasInitialized.current = true;
+		}
+	}, [
+		variantInfo,
+		hasParsedVariantInfo,
+		trackEvent,
+		setSupplementalDefaultProps
+	]);
+};
+
+//#endregion
+export { useUpdateAnalyticsProps };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/hooks/utils.cjs

@@ -0,0 +1,8 @@
+const require_utils = require('../utils-hYTjy7hJ.cjs');
+
+exports.SearchResultsState = require_utils.SearchResultsState;
+exports.createAppLoadedEvent = require_utils.createAppLoadedEvent;
+exports.createVisitUserEvent = require_utils.createVisitUserEvent;
+exports.getSearchResultsState = require_utils.getSearchResultsState;
+exports.isElementPartiallyVisible = require_utils.isElementPartiallyVisible;
+exports.isWithinBusinessHours = require_utils.isWithinBusinessHours;

package/dist/hooks/utils.d.cts

@@ -0,0 +1,13 @@
+import "../index-Bmub8e38.cjs";
+import "../index-CiWEYzXl.cjs";
+import "../index-CESxqFso.cjs";
+import "../utils-B3x_9JTY.cjs";
+import "../index-CG3P8xE1.cjs";
+import "../chatElementDisplayLocation-DWmfNX_u.cjs";
+import "../frontendConfig-tVg0hsWZ.cjs";
+import "../test-types-ThQiO_cc.cjs";
+import "../spiffyWidgets-BuS00VaQ.cjs";
+import "../search-y-ioX5Mz.cjs";
+import "../index-Cyq5HiC0.cjs";
+import { SearchResultsState, createAppLoadedEvent, createVisitUserEvent, getSearchResultsState, isElementPartiallyVisible, isWithinBusinessHours } from "../utils-B7PAzB_M.cjs";
+export { SearchResultsState, createAppLoadedEvent, createVisitUserEvent, getSearchResultsState, isElementPartiallyVisible, isWithinBusinessHours };

package/dist/hooks/utils.d.ts

@@ -0,0 +1,13 @@
+import "../index-C0eAp5f5.js";
+import "../index-BVf069X-.js";
+import "../index-vP8BKdxl.js";
+import "../utils-DyTiotQz.js";
+import "../index-DgjDuQl4.js";
+import "../chatElementDisplayLocation-BoE6DEdv.js";
+import "../frontendConfig-CymUbclV.js";
+import "../test-types-DbrKQIqB.js";
+import "../spiffyWidgets-BnkP5kXf.js";
+import "../search-CIrqYYMI.js";
+import "../index-CJc7_j_v.js";
+import { SearchResultsState, createAppLoadedEvent, createVisitUserEvent, getSearchResultsState, isElementPartiallyVisible, isWithinBusinessHours } from "../utils-CrQ0h9tc.js";
+export { SearchResultsState, createAppLoadedEvent, createVisitUserEvent, getSearchResultsState, isElementPartiallyVisible, isWithinBusinessHours };

package/dist/hooks/utils.js

@@ -0,0 +1,3 @@
+import { SearchResultsState, createAppLoadedEvent, createVisitUserEvent, getSearchResultsState, isElementPartiallyVisible, isWithinBusinessHours } from "../utils-D_kATUj6.js";
+
+export { SearchResultsState, createAppLoadedEvent, createVisitUserEvent, getSearchResultsState, isElementPartiallyVisible, isWithinBusinessHours };

package/dist/index-9NE86em3.d.cts

@@ -0,0 +1,35 @@
+//#region src/config/locators/components/common/buttons.d.ts
+declare const BUTTON_BASE_TESTID = "spiffy-button-base";
+declare const SUGGESTION_BUTTON_TESTID = "spiffy-suggestion-button";
+declare const SWITCH_TO_AGENT_CONTAINER_TESTID = "spiffy-switch-to-agent-button-container";
+declare const SWITCH_TO_LIVE_AGENT_BUTTON_TESTID = "spiffy-switch-to-live-agent-button";
+declare const SWITCH_TO_AI_ASSISTANT_BUTTON_TESTID = "spiffy-switch-to-ai-assistant-button";
+declare const USER_QUERY_BUTTON_TESTID = "spiffy-user-query-button";
+//#endregion
+//#region src/config/locators/components/common/cards.d.ts
+declare const ANIMATED_PRODUCT_CARD_TESTID = "spiffy-animated-product-card";
+declare const MESSAGE_CARD_TESTID = "spiffy-message-card";
+declare const MESSAGE_CONTENT_TESTID = "spiffy-message-content";
+declare const MESSAGE_MARKDOWN_CONTENT_TESTID = "spiffy-message-markdown-content";
+declare const MESSAGE_VARIANT_MARKDOWN = "md";
+declare const MESSAGE_VARIANT_TEXT = "txt";
+declare const EXPAND_COLLAPSE_CARD_TESTID = "spiffy-product-review-card-read-more-container";
+declare const PAGE_CARDS_SCROLL_CONTAINER_TESTID = "spiffy-page-cards-scroll-container";
+declare const PAGE_CARD_DESCRIPTION_TESTID = "spiffy-page-card-description";
+declare const PAGE_CARD_LINK_TESTID = "spiffy-page-card-link";
+declare const PAGE_CARD_TESTID = "spiffy-page-card";
+declare const PAGE_CARD_TITLE_TESTID = "spiffy-page-card-title";
+declare const PAGE_CARD_VIEW_SOURCE_BUTTON_TESTID = "spiffy-page-card-view-source-button";
+declare const PRODUCT_REVIEW_CARD_TESTID = "spiffy-product-review-card";
+declare const PRODUCT_REVIEW_CARD_BUTTON_TESTID = "spiffy-product-review-card-button";
+declare const PRODUCT_CARD_TESTID = "spiffy-product-card";
+declare const PRODUCT_CARDS_SCROLL_CONTAINER_TESTID = "spiffy-product-cards-scroll-container";
+//#endregion
+//#region src/config/locators/components/common/links.d.ts
+declare const PRODUCT_LINK_TESTID = "spiffy-product-link";
+//#endregion
+//#region src/config/locators/components/common/tables.d.ts
+declare const PRODUCTS_COMPARISON_TABLE_CONTAINER_TESTID = "spiffy-products-comparison-table-container";
+//#endregion
+export { ANIMATED_PRODUCT_CARD_TESTID, BUTTON_BASE_TESTID, EXPAND_COLLAPSE_CARD_TESTID, MESSAGE_CARD_TESTID, MESSAGE_CONTENT_TESTID, MESSAGE_MARKDOWN_CONTENT_TESTID, MESSAGE_VARIANT_MARKDOWN, MESSAGE_VARIANT_TEXT, PAGE_CARDS_SCROLL_CONTAINER_TESTID, PAGE_CARD_DESCRIPTION_TESTID, PAGE_CARD_LINK_TESTID, PAGE_CARD_TESTID, PAGE_CARD_TITLE_TESTID, PAGE_CARD_VIEW_SOURCE_BUTTON_TESTID, PRODUCTS_COMPARISON_TABLE_CONTAINER_TESTID, PRODUCT_CARDS_SCROLL_CONTAINER_TESTID, PRODUCT_CARD_TESTID, PRODUCT_LINK_TESTID, PRODUCT_REVIEW_CARD_BUTTON_TESTID, PRODUCT_REVIEW_CARD_TESTID, SUGGESTION_BUTTON_TESTID, SWITCH_TO_AGENT_CONTAINER_TESTID, SWITCH_TO_AI_ASSISTANT_BUTTON_TESTID, SWITCH_TO_LIVE_AGENT_BUTTON_TESTID, USER_QUERY_BUTTON_TESTID };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/index-BVf069X-.d.ts

@@ -0,0 +1,184 @@
+import { CamelCasedPropertiesDeep } from "./index-vP8BKdxl.js";
+import { FormResponseAttributesFormCategory, FormType, FulfillmentDisplayStatus, PDPAttributes, ProductSearchResponseAttributes, QueryTypedAttributes, Response, ResponseCategory, ResponseProductAttributes, SearchAttributes, SearchResponseProduct, Suggestion, SuggestionClickedAttributes, UserEvent } from "@spiffy-ai/commerce-api-client";
+
+//#region src/application/models/guards/api/isApiPDPEventAttributes.d.ts
+declare const isApiPDPAttributes: (data: unknown) => data is PDPAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiQueryTypedEventAttributes.d.ts
+declare const isApiQueryTypedAttributes: (data: unknown) => data is QueryTypedAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiResponse.d.ts
+declare const isApiResponse: (data: unknown) => data is Response;
+//#endregion
+//#region src/application/models/guards/api/isApiProductResponseAttributes.d.ts
+declare const isApiProductResponseAttributes: (attributes: unknown) => attributes is ResponseProductAttributes;
+//#endregion
+//#region src/application/models/api/response.d.ts
+interface ReviewRichInformation extends CamelCasedPropertiesDeep<ApiReviewRichInformation> {}
+type AcceptableFormFieldType = 'string' | 'number' | 'boolean' | 'object' | 'array';
+interface OrderItemInfo$1 {
+  itemTitle: string;
+  itemPrice: number;
+  itemQuantity: number;
+  orderItemId: string;
+  image?: string;
+  inTransitAt?: string;
+  deliveredAt?: string;
+  estimatedDeliveryAt?: string;
+  fulfillmentDisplayStatus?: FulfillmentDisplayStatus;
+  trackingUrl?: string;
+}
+interface OrderResponseAttributes$1 {
+  category: ResponseCategory.Order;
+  attributes: {
+    orderId: string;
+    orderNumber: string;
+    createdAt: string;
+    latestEventDate: string;
+    lineItems: OrderItemInfo$1[];
+  };
+}
+interface TextResponseAttributes {
+  category: ResponseCategory.Text;
+  attributes: CamelCasedPropertiesDeep<ApiTextResponseAttributes>;
+}
+interface ProductResponseAttributes {
+  category: ResponseCategory.Product;
+  attributes: CamelCasedPropertiesDeep<ResponseProductAttributes & {
+    filters?: {
+      [key: string]: string[];
+    };
+  }>;
+}
+interface SearchResponseProductAttributes {
+  category: ResponseCategory.Product;
+  attributes: CamelCasedPropertiesDeep<SearchResponseProduct>;
+}
+interface SearchResponseAttributes {
+  category: ResponseCategory.Text;
+  attributes: CamelCasedPropertiesDeep<ApiSearchResponseAttributes>;
+}
+interface SearchProductResponseAttributes {
+  category: ResponseCategory.ProductSearch;
+  attributes: CamelCasedPropertiesDeep<ProductSearchResponseAttributes>;
+}
+interface SearchProductFilterAttributes {
+  category: ResponseCategory.ProductSearchFilter;
+  attributes: CamelCasedPropertiesDeep<ApiProductSearchFilterResponseAttributes>;
+}
+interface ReviewResponseAttributes {
+  category: ResponseCategory.Review;
+  attributes: CamelCasedPropertiesDeep<ApiReviewResponseAttributes>;
+}
+interface SeparatorResponseAttributes {
+  category: ResponseCategory.Separator;
+}
+interface PageResponseAttributes {
+  category: ResponseCategory.Page;
+  attributes: CamelCasedPropertiesDeep<ApiPageResponseAttributes>;
+}
+interface FormResponseAttributes {
+  category: ResponseCategory.Form;
+  attributes: {
+    formCategory?: {
+      formType: FormType;
+    };
+    schema: {
+      properties: {
+        [key: string]: {
+          type: AcceptableFormFieldType;
+          title: string;
+          format?: 'email';
+        };
+      };
+      required: string[];
+    };
+  };
+}
+type Response$1 = {
+  id: string;
+  createdAt: string;
+  category: ResponseCategory;
+} & (TextResponseAttributes | ProductResponseAttributes | ReviewResponseAttributes | SeparatorResponseAttributes | PageResponseAttributes | SearchProductResponseAttributes | SearchProductFilterAttributes | FormResponseAttributes | OrderResponseAttributes$1);
+//#endregion
+//#region src/application/models/api/responseGenerics.d.ts
+interface ApiReviewRichInformation {
+  cons?: string[];
+  pros?: string[];
+  review_date?: string;
+  reviewer_title?: string;
+  product_familiarity?: 'IVE_TESTED_IT' | 'I_OWN_IT';
+}
+interface ApiTextResponseAttributes {
+  content: string;
+}
+interface ApiSearchResponseAttributes {
+  search_term: string;
+  selected_filters?: string[];
+  filters?: {
+    [key: string]: string[];
+  };
+}
+interface ApiSearchResponseProductAttributes {
+  response_id?: string;
+}
+interface ApiProductSearchFilterResponseAttributes {
+  filter_name: string;
+}
+interface ApiReviewResponseAttributes {
+  id?: string;
+  product_id?: string;
+  title?: string;
+  reviewer?: string;
+  review?: string;
+  stars?: number;
+  rich_information?: ApiReviewRichInformation;
+  onClick?: () => void;
+}
+interface ApiPageResponseAttributes {
+  id?: string;
+  title?: string;
+  description?: string;
+  url?: string;
+}
+interface ApiFormResponseSchemaAttributes {
+  properties: {
+    [key: string]: {
+      format?: 'email';
+      type: AcceptableFormFieldType;
+      title: string;
+    };
+  };
+  required: Array<keyof ApiFormResponseSchemaAttributes['properties']>;
+}
+interface ApiFormResponseAttributes {
+  form_category?: FormResponseAttributesFormCategory;
+  schema: ApiFormResponseSchemaAttributes;
+}
+//#endregion
+//#region src/application/models/guards/api/isApiReviewResponseAttributes.d.ts
+declare const isApiReviewResponseAttributes: (obj: unknown) => obj is ApiReviewResponseAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiReviewRichInformation.d.ts
+declare const isApiReviewRichInformation: (richInfo: unknown) => richInfo is ApiReviewRichInformation;
+//#endregion
+//#region src/application/models/guards/api/isApiSearchEventAttributes.d.ts
+declare const isApiSearchAttributes: (data: unknown) => data is SearchAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiSuggestion.d.ts
+declare const isSuggestion: (data: unknown) => data is Suggestion;
+//#endregion
+//#region src/application/models/guards/api/isApiSuggestionClickedEventAttributes.d.ts
+declare const isApiSuggestionClickedAttributes: (data: unknown) => data is SuggestionClickedAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiTextResponseAttributes.d.ts
+declare const isApiTextResponseAttributes: (attributes: unknown) => attributes is ApiTextResponseAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiUserEvent.d.ts
+declare const isApiUserEvent: (data: unknown) => data is UserEvent;
+//#endregion
+//#region src/application/models/guards/api/isApiProductSearchAttributes.d.ts
+declare const isApiProductSearchResponseAttributes: (attributes: unknown) => attributes is ProductSearchResponseAttributes;
+//#endregion
+export { AcceptableFormFieldType, ApiFormResponseAttributes, ApiFormResponseSchemaAttributes, ApiPageResponseAttributes, ApiProductSearchFilterResponseAttributes, ApiReviewResponseAttributes, ApiReviewRichInformation, ApiSearchResponseAttributes, ApiSearchResponseProductAttributes, ApiTextResponseAttributes, FormResponseAttributes, OrderItemInfo$1 as OrderItemInfo, OrderResponseAttributes$1 as OrderResponseAttributes, PageResponseAttributes, ProductResponseAttributes, Response$1 as Response, ReviewResponseAttributes, ReviewRichInformation, SearchProductFilterAttributes, SearchProductResponseAttributes, SearchResponseAttributes, SearchResponseProductAttributes, SeparatorResponseAttributes, TextResponseAttributes, isApiPDPAttributes, isApiProductResponseAttributes, isApiProductSearchResponseAttributes, isApiQueryTypedAttributes, isApiResponse, isApiReviewResponseAttributes, isApiReviewRichInformation, isApiSearchAttributes, isApiSuggestionClickedAttributes, isApiTextResponseAttributes, isApiUserEvent, isSuggestion };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-BVf069X-.d.ts","names":[],"sources":["../src/application/models/guards/api/isApiPDPEventAttributes.d.ts","../src/application/models/guards/api/isApiQueryTypedEventAttributes.d.ts","../src/application/models/guards/api/isApiResponse.d.ts","../src/application/models/guards/api/isApiProductResponseAttributes.d.ts","../src/application/models/api/response.d.ts","../src/application/models/api/responseGenerics.d.ts","../src/application/models/guards/api/isApiReviewResponseAttributes.d.ts","../src/application/models/guards/api/isApiReviewRichInformation.d.ts","../src/application/models/guards/api/isApiSearchEventAttributes.d.ts","../src/application/models/guards/api/isApiSuggestion.d.ts","../src/application/models/guards/api/isApiSuggestionClickedEventAttributes.d.ts","../src/application/models/guards/api/isApiTextResponseAttributes.d.ts","../src/application/models/guards/api/isApiUserEvent.d.ts","../src/application/models/guards/api/isApiProductSearchAttributes.d.ts"],"sourcesContent":["import { PDPAttributes } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiPDPAttributes: (data: unknown) => data is PDPAttributes;\n","import { QueryTypedAttributes } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiQueryTypedAttributes: (data: unknown) => data is QueryTypedAttributes;\n","import { Response } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiResponse: (data: unknown) => data is Response;\n","import { ResponseProductAttributes } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiProductResponseAttributes: (attributes: unknown) => attributes is ResponseProductAttributes;\n","import { ResponseCategory } from '@spiffy-ai/commerce-api-client';\nimport { CamelCasedPropertiesDeep } from 'src/application/models/utilityTypes';\nimport type { ProductSearchResponseAttributes as ApiProductSearchResponseAttributes, ResponseProductAttributes as ApiProductResponseAttributes, SearchResponseProduct as ApiSearchResponseProduct, FormType, FulfillmentDisplayStatus } from '@spiffy-ai/commerce-api-client';\nimport { ApiReviewResponseAttributes, ApiReviewRichInformation, ApiPageResponseAttributes, ApiTextResponseAttributes, ApiSearchResponseAttributes, ApiProductSearchFilterResponseAttributes } from 'src/application/models/api/responseGenerics';\nexport interface ReviewRichInformation extends CamelCasedPropertiesDeep<ApiReviewRichInformation> {\n}\nexport type AcceptableFormFieldType = 'string' | 'number' | 'boolean' | 'object' | 'array';\nexport interface OrderItemInfo {\n    itemTitle: string;\n    itemPrice: number;\n    itemQuantity: number;\n    orderItemId: string;\n    image?: string;\n    inTransitAt?: string;\n    deliveredAt?: string;\n    estimatedDeliveryAt?: string;\n    fulfillmentDisplayStatus?: FulfillmentDisplayStatus;\n    trackingUrl?: string;\n}\nexport interface OrderResponseAttributes {\n    category: ResponseCategory.Order;\n    attributes: {\n        orderId: string;\n        orderNumber: string;\n        createdAt: string;\n        latestEventDate: string;\n        lineItems: OrderItemInfo[];\n    };\n}\nexport interface TextResponseAttributes {\n    category: ResponseCategory.Text;\n    attributes: CamelCasedPropertiesDeep<ApiTextResponseAttributes>;\n}\nexport interface ProductResponseAttributes {\n    category: ResponseCategory.Product;\n    attributes: CamelCasedPropertiesDeep<ApiProductResponseAttributes & {\n        filters?: {\n            [key: string]: string[];\n        };\n    }>;\n}\nexport interface SearchResponseProductAttributes {\n    category: ResponseCategory.Product;\n    attributes: CamelCasedPropertiesDeep<ApiSearchResponseProduct>;\n}\nexport interface SearchResponseAttributes {\n    category: ResponseCategory.Text;\n    attributes: CamelCasedPropertiesDeep<ApiSearchResponseAttributes>;\n}\nexport interface SearchProductResponseAttributes {\n    category: ResponseCategory.ProductSearch;\n    attributes: CamelCasedPropertiesDeep<ApiProductSearchResponseAttributes>;\n}\nexport interface SearchProductFilterAttributes {\n    category: ResponseCategory.ProductSearchFilter;\n    attributes: CamelCasedPropertiesDeep<ApiProductSearchFilterResponseAttributes>;\n}\nexport interface ReviewResponseAttributes {\n    category: ResponseCategory.Review;\n    attributes: CamelCasedPropertiesDeep<ApiReviewResponseAttributes>;\n}\nexport interface SeparatorResponseAttributes {\n    category: ResponseCategory.Separator;\n}\nexport interface PageResponseAttributes {\n    category: ResponseCategory.Page;\n    attributes: CamelCasedPropertiesDeep<ApiPageResponseAttributes>;\n}\nexport interface FormResponseAttributes {\n    category: ResponseCategory.Form;\n    attributes: {\n        formCategory?: {\n            formType: FormType;\n        };\n        schema: {\n            properties: {\n                [key: string]: {\n                    type: AcceptableFormFieldType;\n                    title: string;\n                    format?: 'email';\n                };\n            };\n            required: string[];\n        };\n    };\n}\nexport type Response = {\n    id: string;\n    createdAt: string;\n    category: ResponseCategory;\n} & (TextResponseAttributes | ProductResponseAttributes | ReviewResponseAttributes | SeparatorResponseAttributes | PageResponseAttributes | SearchProductResponseAttributes | SearchProductFilterAttributes | FormResponseAttributes | OrderResponseAttributes);\n","import { FormResponseAttributesFormCategory } from '@spiffy-ai/commerce-api-client';\nimport { AcceptableFormFieldType } from './response';\nexport interface ApiReviewRichInformation {\n    cons?: string[];\n    pros?: string[];\n    review_date?: string;\n    reviewer_title?: string;\n    product_familiarity?: 'IVE_TESTED_IT' | 'I_OWN_IT';\n}\nexport interface ApiTextResponseAttributes {\n    content: string;\n}\nexport interface ApiSearchResponseAttributes {\n    search_term: string;\n    selected_filters?: string[];\n    filters?: {\n        [key: string]: string[];\n    };\n}\nexport interface ApiSearchResponseProductAttributes {\n    response_id?: string;\n}\nexport interface ApiProductSearchFilterResponseAttributes {\n    filter_name: string;\n}\nexport interface ApiReviewResponseAttributes {\n    id?: string;\n    product_id?: string;\n    title?: string;\n    reviewer?: string;\n    review?: string;\n    stars?: number;\n    rich_information?: ApiReviewRichInformation;\n    onClick?: () => void;\n}\nexport interface ApiPageResponseAttributes {\n    id?: string;\n    title?: string;\n    description?: string;\n    url?: string;\n}\nexport interface ApiFormResponseSchemaAttributes {\n    properties: {\n        [key: string]: {\n            format?: 'email';\n            type: AcceptableFormFieldType;\n            title: string;\n        };\n    };\n    required: Array<keyof ApiFormResponseSchemaAttributes['properties']>;\n}\nexport interface ApiFormResponseAttributes {\n    form_category?: FormResponseAttributesFormCategory;\n    schema: ApiFormResponseSchemaAttributes;\n}\n","import { ApiReviewResponseAttributes } from 'src/application/models/api/responseGenerics';\nexport declare const isApiReviewResponseAttributes: (obj: unknown) => obj is ApiReviewResponseAttributes;\n","import { ApiReviewRichInformation } from 'src/application/models/api/responseGenerics';\nexport declare const isApiReviewRichInformation: (richInfo: unknown) => richInfo is ApiReviewRichInformation;\n","import { SearchAttributes } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiSearchAttributes: (data: unknown) => data is SearchAttributes;\n","import { Suggestion as CommerceSuggestion } from '@spiffy-ai/commerce-api-client';\nexport declare const isSuggestion: (data: unknown) => data is CommerceSuggestion;\n","import { SuggestionClickedAttributes } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiSuggestionClickedAttributes: (data: unknown) => data is SuggestionClickedAttributes;\n","import { ApiTextResponseAttributes } from 'src/application/models/api/responseGenerics';\nexport declare const isApiTextResponseAttributes: (attributes: unknown) => attributes is ApiTextResponseAttributes;\n","import { UserEvent } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiUserEvent: (data: unknown) => data is UserEvent;\n","import { ProductSearchResponseAttributes } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiProductSearchResponseAttributes: (attributes: unknown) => attributes is ProductSearchResponseAttributes;\n"],"mappings":";;;;AACA,IAAW,qBAAqB,CAAC,WAAW,cAAc;;;;ACA1D,IAAW,4BAA4B,CAAC,WAAW,qBAAqB;;;;ACAxE,IAAW,gBAAgB,CAAC,WAAW,SAAS;;;;ACAhD,IAAW,iCAAiC,CAAC,WAAW,0BAA0B;;;;ACGlF,IAAW,wBAAwB;CAAC;OAAW;OAAgC;CAAmB;AAClG,IAAA,0BAAA,CAAA,IAAA;AACA,IAAW,kBAAgB,CAAC,WAAW,yBAAyB;AAChE,IAAW,4BAAoB;CAAA;OAAA,iBAAA;OAAA;CAAA;AAC/B,IAAW,yBAAU;CAAA;OAAA,iBAAA;OAAA;OAAA;CAAA;AACrB,IAAW,4BAAU;CAAA;OAAA,iBAAA;OAAA;OAAA;CAAA;AACrB,IAAW,kCAAa;CAAA;OAAA,iBAAA;OAAA;OAAA;CAAA;AACxB,IAAW,2BAAY;CAAA;OAAA,iBAAA;OAAA;OAAA;CAAA;AACvB,IAAW,kCAAO;CAAA;OAAA,iBAAA;OAAA;OAAA;CAAA;AAClB,IAAW,gCAAa;CAAA;OAAA,iBAAA;OAAA;OAAA;CAAA;AACxB,IAAW,2BAAa;CAAA;OAAA,iBAAA;OAAA;OAAA;CAAA;AACxB,IAAW,8BAAqB,CAAA,WAAA,iBAAA,UAAA;AAChC,IAAW,yBAAyB;CAAC;OAAW,iBAAO;OAAA;OAAA;CAAA;AACvD,IAAW,yBAAa;CAAA;OAAA,iBAAA;OAAA;OAAA;CAAA;AACxB,IAAA,aAAA;CAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA;;;;AChBA,IAAW,2BAA2B,CAAC,IAAG;AAC1C,IAAW,4BAAQ,CAAA,IAAA;AACnB,IAAW,8BAAQ,CAAA,IAAA;AACnB,IAAW,qCAAa,CAAA,IAAA;AACxB,IAAW,2CAAgB,CAAA,IAAA;AAC3B,IAAW,8BAA8B,CAAC,WAAW,yBAAC;AACtD,IAAA,4BAAA,CAAA,IAAA;AACA,IAAW,kCAAgC;CAAA;OAAA;OAAA;OAAA;CAAA;AAC3C,IAAW,4BAAQ;CAAA;OAAA;OAAA;CAAA;;;;ACTnB,IAAW,gCAAgC,CAAC,WAAW,4BAA4B;;;;ACAnF,IAAW,6BAA6B,CAAC,WAAW,yBAAyB;;;;ACA7E,IAAW,wBAAwB,CAAC,WAAW,iBAAiB;;;;ACAhE,IAAW,eAAe,CAAC,WAAW,WAAmB;;;;ACAzD,IAAW,mCAAmC,CAAC,WAAW,4BAA4B;;;;ACAtF,IAAW,8BAA8B,CAAC,WAAW,0BAA0B;;;;ACA/E,IAAW,iBAAiB,CAAC,WAAW,UAAU;;;;ACAlD,IAAW,uCAAuC,CAAC,WAAW,gCAAgC"}

package/dist/index-B_KJB5L_.d.cts

@@ -0,0 +1,186 @@
+import { ProductResponseAttributes } from "./index-CiWEYzXl.cjs";
+import { Message } from "./index-CG3P8xE1.cjs";
+import { SearchParams, SearchResult } from "./search-y-ioX5Mz.cjs";
+import { ChatSearchFilter, ChatSearchStateType, ProductSorting } from "./types-CKMMb_gX.cjs";
+import * as jotai58 from "jotai";
+
+//#region src/atoms/search/chatSearch.d.ts
+declare const chatSearchStateAtom: jotai58.PrimitiveAtom<ChatSearchStateType> & {
+  init: ChatSearchStateType;
+};
+declare const chatSearchHasProductsAtom: jotai58.PrimitiveAtom<boolean> & {
+  init: boolean;
+};
+declare const chatSearchProductSortingAtom: jotai58.PrimitiveAtom<ProductSorting> & {
+  init: ProductSorting;
+};
+type ChatSearchTurn = {
+  id: string;
+  generatedQuery?: string;
+  productCount: number;
+  productList: ProductResponseAttributes["attributes"][];
+  filterList: string[];
+  messages: Message[];
+};
+declare const chatSearchIsLoadingAtom: jotai58.PrimitiveAtom<boolean> & {
+  init: boolean;
+};
+type SelectedChatSearchFilterOption = {
+  id: string;
+  displayName: string;
+  filterId: string;
+  filterItemId: string;
+};
+declare const selectedFilterOptionsAtom: jotai58.PrimitiveAtom<SelectedChatSearchFilterOption[]> & {
+  init: SelectedChatSearchFilterOption[];
+};
+declare const additiveDynamicFiltersAtom: jotai58.Atom<boolean>;
+declare const createChatSearchFilterOption: (filterId: string, filterItemId: string, displayName: string) => SelectedChatSearchFilterOption;
+declare const chatSearchParamsAtom: jotai58.WritableAtom<{
+  id: string | null;
+  query: string | null;
+}, [value: {
+  id: string | null;
+  query: string | null;
+}], void>;
+declare const chatSearchQueryAtom: jotai58.WritableAtom<string | null, [value: string | null], void>;
+declare const chatSearchIdAtom: jotai58.WritableAtom<string | null, [value: string | null], void>;
+declare const ChatSearchTurnAtom: jotai58.Atom<{
+  productList: {
+    averageRating?: number | undefined;
+    colors?: string[] | undefined;
+    description?: string | undefined;
+    filters?: {
+      [x: string]: string[];
+    } | undefined;
+    id: string;
+    imageUrl?: string | undefined;
+    imageUrls?: string[] | undefined;
+    isForGrid?: boolean | undefined;
+    metadata?: {
+      label: string;
+      value: string;
+    }[] | undefined;
+    numberReviews?: number | undefined;
+    originalPrice?: number | undefined;
+    salePrice?: number | undefined;
+    sizes?: string[] | undefined;
+    title: string;
+    url: string;
+  }[];
+  productCount: number;
+  id: string;
+  generatedQuery?: string;
+  filterList: string[];
+  messages: Message[];
+} | null>;
+declare const chatSearchProducts: jotai58.Atom<{
+  averageRating?: number | undefined;
+  colors?: string[] | undefined;
+  description?: string | undefined;
+  filters?: {
+    [x: string]: string[];
+  } | undefined;
+  id: string;
+  imageUrl?: string | undefined;
+  imageUrls?: string[] | undefined;
+  isForGrid?: boolean | undefined;
+  metadata?: {
+    label: string;
+    value: string;
+  }[] | undefined;
+  numberReviews?: number | undefined;
+  originalPrice?: number | undefined;
+  salePrice?: number | undefined;
+  sizes?: string[] | undefined;
+  title: string;
+  url: string;
+}[]>;
+declare const chatSearchFiltersAtom: jotai58.Atom<ChatSearchFilter[]>;
+declare const setSearchParams: (query: string) => void;
+declare const getSearchParamsAtom: jotai58.Atom<{
+  es: string | null;
+  esq: string | null;
+}>;
+declare const initiateChatSearchAtom: jotai58.WritableAtom<null, [query: string], void> & {
+  init: null;
+};
+declare const handleSearchResultsAtom: jotai58.WritableAtom<null, [message: Message | undefined], void> & {
+  init: null;
+};
+declare const setChatSearchParamsAtom: jotai58.WritableAtom<null, [query: string], void> & {
+  init: null;
+};
+//#endregion
+//#region src/atoms/search/searchAPI.d.ts
+type SelectedFilterOption = {
+  id: string;
+  displayName: string;
+  filterId: string;
+  filterItemId: string;
+};
+interface SearchState {
+  data: SearchResult | null;
+  loading: boolean;
+  error: string | null;
+  lastQuery: string | null;
+}
+declare const searchAtom: jotai58.PrimitiveAtom<SearchState> & {
+  init: SearchState;
+};
+declare const searchProductSortingAtom: jotai58.PrimitiveAtom<ProductSorting> & {
+  init: ProductSorting;
+};
+declare const searchSelectedFiltersAtom: jotai58.PrimitiveAtom<SelectedFilterOption[]> & {
+  init: SelectedFilterOption[];
+};
+declare const createFilterOption: (filterId: string, filterItemId: string, displayName: string) => SelectedFilterOption;
+declare const searchParamsAtom: jotai58.WritableAtom<{
+  id: string | null;
+  query: string | null;
+}, [value: {
+  id: string | null;
+  query: string | null;
+}], void>;
+declare const internalSearchSystemStateAtom: jotai58.PrimitiveAtom<boolean> & {
+  init: boolean;
+};
+declare const searchSystemAtom: jotai58.WritableAtom<boolean, [value: boolean], void>;
+declare const filteredSearchProductsAtom: jotai58.Atom<{
+  averageRating?: number | undefined;
+  colors?: string[] | undefined;
+  description?: string | undefined;
+  filters?: {
+    [x: string]: string[];
+  } | undefined;
+  id: string;
+  imageUrl?: string | undefined;
+  imageUrls?: string[] | undefined;
+  isForGrid?: boolean | undefined;
+  metadata?: {
+    label: string;
+    value: string;
+  }[] | undefined;
+  numberReviews?: number | undefined;
+  originalPrice?: number | undefined;
+  salePrice?: number | undefined;
+  sizes?: string[] | undefined;
+  title: string;
+  url: string;
+}[]>;
+declare const searchFiltersAtom: jotai58.Atom<ChatSearchFilter[]>;
+declare const addSearchFilterAtom: jotai58.WritableAtom<null, [filter: SelectedFilterOption], void> & {
+  init: null;
+};
+declare const removeSearchFilterAtom: jotai58.WritableAtom<null, [filterId: string], void> & {
+  init: null;
+};
+declare const clearSearchFiltersAtom: jotai58.WritableAtom<null, [], void> & {
+  init: null;
+};
+declare const performSearchAtom: jotai58.WritableAtom<null, [params: SearchParams, allowRedirect?: unknown], Promise<void>> & {
+  init: null;
+};
+//#endregion
+export { ChatSearchTurn, ChatSearchTurnAtom, SelectedChatSearchFilterOption, SelectedFilterOption, addSearchFilterAtom, additiveDynamicFiltersAtom, chatSearchFiltersAtom, chatSearchHasProductsAtom, chatSearchIdAtom, chatSearchIsLoadingAtom, chatSearchParamsAtom, chatSearchProductSortingAtom, chatSearchProducts, chatSearchQueryAtom, chatSearchStateAtom, clearSearchFiltersAtom, createChatSearchFilterOption, createFilterOption, filteredSearchProductsAtom, getSearchParamsAtom, handleSearchResultsAtom, initiateChatSearchAtom, internalSearchSystemStateAtom, performSearchAtom, removeSearchFilterAtom, searchAtom, searchFiltersAtom, searchParamsAtom, searchProductSortingAtom, searchSelectedFiltersAtom, searchSystemAtom, selectedFilterOptionsAtom, setChatSearchParamsAtom, setSearchParams };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-B_KJB5L_.d.cts","names":[],"sources":["../src/atoms/search/chatSearch.d.ts","../src/atoms/search/searchAPI.d.ts"],"sourcesContent":["import { Message, ProductResponseAttributes } from \"src/application/models\";\nimport { ChatSearchStateType, ProductSorting } from \"./types\";\nexport declare const chatSearchStateAtom: import(\"jotai\").PrimitiveAtom<ChatSearchStateType> & {\n    init: ChatSearchStateType;\n};\nexport declare const chatSearchHasProductsAtom: import(\"jotai\").PrimitiveAtom<boolean> & {\n    init: boolean;\n};\nexport declare const chatSearchProductSortingAtom: import(\"jotai\").PrimitiveAtom<ProductSorting> & {\n    init: ProductSorting;\n};\nexport type ChatSearchTurn = {\n    id: string;\n    generatedQuery?: string;\n    productCount: number;\n    productList: ProductResponseAttributes[\"attributes\"][];\n    filterList: string[];\n    messages: Message[];\n};\nexport declare const chatSearchIsLoadingAtom: import(\"jotai\").PrimitiveAtom<boolean> & {\n    init: boolean;\n};\nexport type SelectedChatSearchFilterOption = {\n    id: string;\n    displayName: string;\n    filterId: string;\n    filterItemId: string;\n};\nexport declare const selectedFilterOptionsAtom: import(\"jotai\").PrimitiveAtom<SelectedChatSearchFilterOption[]> & {\n    init: SelectedChatSearchFilterOption[];\n};\nexport declare const additiveDynamicFiltersAtom: import(\"jotai\").Atom<boolean>;\nexport declare const createChatSearchFilterOption: (filterId: string, filterItemId: string, displayName: string) => SelectedChatSearchFilterOption;\nexport declare const chatSearchParamsAtom: import(\"jotai\").WritableAtom<{\n    id: string | null;\n    query: string | null;\n}, [value: {\n    id: string | null;\n    query: string | null;\n}], void>;\nexport declare const chatSearchQueryAtom: import(\"jotai\").WritableAtom<string | null, [value: string | null], void>;\nexport declare const chatSearchIdAtom: import(\"jotai\").WritableAtom<string | null, [value: string | null], void>;\nexport declare const ChatSearchTurnAtom: import(\"jotai\").Atom<{\n    productList: {\n        averageRating?: number | undefined;\n        colors?: string[] | undefined;\n        description?: string | undefined;\n        filters?: {\n            [x: string]: string[];\n        } | undefined;\n        id: string;\n        imageUrl?: string | undefined;\n        imageUrls?: string[] | undefined;\n        isForGrid?: boolean | undefined;\n        metadata?: {\n            label: string;\n            value: string;\n        }[] | undefined;\n        numberReviews?: number | undefined;\n        originalPrice?: number | undefined;\n        salePrice?: number | undefined;\n        sizes?: string[] | undefined;\n        title: string;\n        url: string;\n    }[];\n    productCount: number;\n    id: string;\n    generatedQuery?: string;\n    filterList: string[];\n    messages: Message[];\n} | null>;\nexport declare const chatSearchProducts: import(\"jotai\").Atom<{\n    averageRating?: number | undefined;\n    colors?: string[] | undefined;\n    description?: string | undefined;\n    filters?: {\n        [x: string]: string[];\n    } | undefined;\n    id: string;\n    imageUrl?: string | undefined;\n    imageUrls?: string[] | undefined;\n    isForGrid?: boolean | undefined;\n    metadata?: {\n        label: string;\n        value: string;\n    }[] | undefined;\n    numberReviews?: number | undefined;\n    originalPrice?: number | undefined;\n    salePrice?: number | undefined;\n    sizes?: string[] | undefined;\n    title: string;\n    url: string;\n}[]>;\nexport declare const chatSearchFiltersAtom: import(\"jotai\").Atom<import(\"./types\").ChatSearchFilter[]>;\nexport declare const setSearchParams: (query: string) => void;\nexport declare const getSearchParamsAtom: import(\"jotai\").Atom<{\n    es: string | null;\n    esq: string | null;\n}>;\nexport declare const initiateChatSearchAtom: import(\"jotai\").WritableAtom<null, [query: string], void> & {\n    init: null;\n};\nexport declare const handleSearchResultsAtom: import(\"jotai\").WritableAtom<null, [message: Message | undefined], void> & {\n    init: null;\n};\nexport declare const setChatSearchParamsAtom: import(\"jotai\").WritableAtom<null, [query: string], void> & {\n    init: null;\n};\n","import { SearchResult, SearchParams } from \"src/application/models/api/search\";\nimport { ProductSorting } from \"./types\";\nexport type SelectedFilterOption = {\n    id: string;\n    displayName: string;\n    filterId: string;\n    filterItemId: string;\n};\ninterface SearchState {\n    data: SearchResult | null;\n    loading: boolean;\n    error: string | null;\n    lastQuery: string | null;\n}\nexport declare const searchAtom: import(\"jotai\").PrimitiveAtom<SearchState> & {\n    init: SearchState;\n};\nexport declare const searchProductSortingAtom: import(\"jotai\").PrimitiveAtom<ProductSorting> & {\n    init: ProductSorting;\n};\nexport declare const searchSelectedFiltersAtom: import(\"jotai\").PrimitiveAtom<SelectedFilterOption[]> & {\n    init: SelectedFilterOption[];\n};\nexport declare const createFilterOption: (filterId: string, filterItemId: string, displayName: string) => SelectedFilterOption;\nexport declare const searchParamsAtom: import(\"jotai\").WritableAtom<{\n    id: string | null;\n    query: string | null;\n}, [value: {\n    id: string | null;\n    query: string | null;\n}], void>;\nexport declare const internalSearchSystemStateAtom: import(\"jotai\").PrimitiveAtom<boolean> & {\n    init: boolean;\n};\nexport declare const searchSystemAtom: import(\"jotai\").WritableAtom<boolean, [value: boolean], void>;\nexport declare const filteredSearchProductsAtom: import(\"jotai\").Atom<{\n    averageRating?: number | undefined;\n    colors?: string[] | undefined;\n    description?: string | undefined;\n    filters?: {\n        [x: string]: string[];\n    } | undefined;\n    id: string;\n    imageUrl?: string | undefined;\n    imageUrls?: string[] | undefined;\n    isForGrid?: boolean | undefined;\n    metadata?: {\n        label: string;\n        value: string;\n    }[] | undefined;\n    numberReviews?: number | undefined;\n    originalPrice?: number | undefined;\n    salePrice?: number | undefined;\n    sizes?: string[] | undefined;\n    title: string;\n    url: string;\n}[]>;\nexport declare const searchFiltersAtom: import(\"jotai\").Atom<import(\"./types\").ChatSearchFilter[]>;\nexport declare const addSearchFilterAtom: import(\"jotai\").WritableAtom<null, [filter: SelectedFilterOption], void> & {\n    init: null;\n};\nexport declare const removeSearchFilterAtom: import(\"jotai\").WritableAtom<null, [filterId: string], void> & {\n    init: null;\n};\nexport declare const clearSearchFiltersAtom: import(\"jotai\").WritableAtom<null, [], void> & {\n    init: null;\n};\nexport declare const performSearchAtom: import(\"jotai\").WritableAtom<null, [params: SearchParams, allowRedirect?: unknown], Promise<void>> & {\n    init: null;\n};\nexport {};\n"],"mappings":";;;;;;;AAIA,IAAC,sBAAA;CAAA;OAAA;OAAA,QAAA;OAAA;CAAA;AACD,IAAW,4BAA4B,CAAC,WAAW,QAAQ,cAAc;AACzE,IAAW,+BAAM;CAAA;OAAA;OAAA,QAAA;OAAA;CAAA;AACjB,IAAC,iBAAA;CAAA;OAAA;OAAA;CAAA;AACD,IAAW,0BAA0B,CAAC,WAAW,QAAQ,cAAc;AACvE,IAAW,iCAAa,CAAA,IAAA;AACxB,IAAC,4BAAA;CAAA;OAAA;OAAA,QAAA;OAAA;CAAA;AACD,IAAW,6BAAkB,CAAA,WAAA,QAAA,KAAA;AAC7B,IAAW,+BAAG,CAAA,WAAA,+BAAA;AACd,IAAW,uBAAgB,CAAA,WAAA,QAAA,aAAA;AAC3B,IAAW,sBAAa,CAAA,WAAA,QAAA,aAAA;AACxB,IAAW,mBAAmB,CAAC,WAAW,QAAQ,aAAQ;AAC1D,IAAW,qBAAa;CAAA;OAAA;OAAA,QAAA;CAAA;AACxB,IAAW,qBAAY,CAAA,WAAA,QAAA,KAAA;AACvB,IAAC,wBAAA;CAAA;OAAA;OAAA,QAAA;CAAA;AACD,IAAW,kBAAkB,CAAC,IAAI;AAClC,IAAW,sBAAM,CAAA,WAAA,QAAA,KAAA;AACjB,IAAC,yBAAA,CAAA,WAAA,QAAA,aAAA;AACD,IAAW,0BAA0B;CAAC;OAAO;OAAA,QAAA;CAAA;AAC7C,IAAW,0BAAG,CAAA,WAAA,QAAA,aAAA;;;;ACnBd,IAAW,uBAAY,CAAA,IAAA;AACvB,IAAI,cAAc,CAAC,WAAC,aAAA;AACpB,IAAW,aAAa;CAAA;OAAA;OAAA,QAAA;OAAA;CAAA;AACxB,IAAC,2BAAA;CAAA;OAAA;OAAA,QAAA;OAAA;CAAA;AACD,IAAW,4BAAW;CAAA;OAAA;OAAA,QAAA;OAAA;CAAA;AACtB,IAAW,qBAAkB,CAAA,WAAA,qBAAA;AAC7B,IAAW,mBAAS,CAAA,WAAA,QAAA,aAAA;AACpB,IAAW,gCAAa,CAAA,WAAA,QAAA,cAAA;AACxB,IAAW,mBAAiB,CAAA,WAAA,QAAA,aAAA;AAC5B,IAAA,6BAAA,CAAA,WAAA,QAAA,KAAA;AACA,IAAW,oBAAoB;CAAC;OAAW;OAAiC,QAAE;CAAA;AAC9E,IAAW,sBAAU;CAAA;OAAA;OAAA,QAAA;CAAA;AACrB,IAAC,yBAAA,CAAA,WAAA,QAAA,aAAA;AACD,IAAW,yBAAyB,CAAC,WAAW,QAAQ,aAAa;AACrE,IAAW,oBAAa;CAAA;OAAA;OAAA;OAAA,QAAA;CAAA"}