@envive-ai/react-hooks 0.2.6-alpha-6 → 0.2.6-alpha-7

package/dist/src/application/models/validators/validateResponse.js

@@ -0,0 +1,173 @@
+import { ResponseCategory } from "@spiffy-ai/commerce-api-client";
+import { isApiPageResponseAttributes } from "src/application/models/guards/api/isApiPageResponseAttributes";
+import { isApiProductResponseAttributes } from "src/application/models/guards/api/isApiProductResponseAttributes";
+import { isApiResponse } from "src/application/models/guards/api/isApiResponse";
+import { isApiReviewResponseAttributes } from "src/application/models/guards/api/isApiReviewResponseAttributes";
+import { isApiTextResponseAttributes } from "src/application/models/guards/api/isApiTextResponseAttributes";
+import { isApiProductSearchResponseAttributes } from "src/application/models/guards/api/isApiProductSearchAttributes";
+import { isApiFormResponseAttributes } from "src/application/models/guards/api/isApiFormResponse";
+import { isApiOrderResponseAttributes } from "src/application/models/guards/api/isApiOrderResponseAttributes";
+import { stringToFulfillmentDisplayStatusEnumValue } from "src/application/models/utils/stringToFulfillmentDisplayStatusEnumValue";
+import { isApiProductSearchFilterResponseAttributes } from "src/application/models/guards/api/isApiProductSearchFilterAttributes";
+const richInformationFromCommerceRichInformation = (data) => ({
+    cons: data.cons,
+    pros: data.pros,
+    reviewDate: data.review_date,
+    reviewerTitle: data.reviewer_title,
+    productFamiliarity: data.product_familiarity,
+});
+export const validateResponse = (data) => {
+    if (!isApiResponse(data)) {
+        return undefined;
+    }
+    if (data.category === ResponseCategory.Text &&
+        isApiTextResponseAttributes(data.attributes)) {
+        return {
+            id: data.id,
+            createdAt: data.createdAt,
+            category: ResponseCategory.Text,
+            attributes: {
+                content: data.attributes.content,
+            },
+        };
+    }
+    if (data.category === ResponseCategory.Product &&
+        isApiProductResponseAttributes(data.attributes)) {
+        return {
+            id: data.id,
+            createdAt: data.createdAt,
+            category: ResponseCategory.Product,
+            attributes: {
+                id: data.attributes.id,
+                description: data.attributes.description,
+                imageUrl: data.attributes.imageUrl,
+                imageUrls: data.attributes.imageUrls,
+                title: data.attributes.title,
+                url: data.attributes.url,
+                originalPrice: data.attributes.originalPrice,
+                salePrice: data.attributes.salePrice,
+                averageRating: data.attributes.averageRating,
+                numberReviews: data.attributes.numberReviews,
+                metadata: data.attributes.metadata,
+                isForGrid: data.attributes.isForGrid,
+                colors: data.attributes.colors,
+                sizes: data.attributes.sizes,
+                filters: data.attributes.filters,
+            },
+        };
+    }
+    if (data.category === ResponseCategory.Review &&
+        isApiReviewResponseAttributes(data.attributes)) {
+        return {
+            id: data.id,
+            createdAt: data.createdAt,
+            category: ResponseCategory.Review,
+            attributes: {
+                id: data.attributes.id,
+                productId: data.attributes.productId,
+                title: data.attributes.title,
+                reviewer: data.attributes.reviewer,
+                review: data.attributes.review,
+                stars: data.attributes.stars,
+                richInformation: data.attributes.richInformation
+                    ? richInformationFromCommerceRichInformation(data.attributes.richInformation)
+                    : undefined,
+            },
+        };
+    }
+    if (data.category === ResponseCategory.Separator) {
+        return {
+            id: data.id,
+            createdAt: data.createdAt,
+            category: ResponseCategory.Separator,
+        };
+    }
+    if (data.category === ResponseCategory.Page &&
+        isApiPageResponseAttributes(data.attributes)) {
+        return {
+            id: data.id,
+            createdAt: data.createdAt,
+            category: ResponseCategory.Page,
+            attributes: {
+                id: data.attributes.id,
+                title: data.attributes.title,
+                description: data.attributes.description,
+                url: data.attributes.url,
+            },
+        };
+    }
+    if (data.category === ResponseCategory.Form &&
+        isApiFormResponseAttributes(data.attributes)) {
+        return {
+            id: data.id,
+            createdAt: data.createdAt,
+            category: ResponseCategory.Form,
+            attributes: {
+                formCategory: data.attributes.formCategory
+                    ? {
+                        formType: data.attributes.formCategory.formType,
+                    }
+                    : undefined,
+                schema: {
+                    properties: data.attributes.schema.properties,
+                    required: data.attributes.schema.required.map(String),
+                },
+            },
+        };
+    }
+    if (data.category === ResponseCategory.ProductSearch &&
+        isApiProductSearchResponseAttributes(data.attributes)) {
+        return {
+            id: data.id,
+            createdAt: data.createdAt,
+            category: ResponseCategory.ProductSearch,
+            attributes: {
+                generatedQuery: data.attributes.generated_query,
+                productCount: data.attributes.product_count,
+            },
+        };
+    }
+    if (data.category === ResponseCategory.ProductSearchFilter &&
+        isApiProductSearchFilterResponseAttributes(data.attributes)) {
+        return {
+            id: data.id,
+            createdAt: data.createdAt,
+            category: ResponseCategory.ProductSearchFilter,
+            attributes: {
+                filterName: data.attributes.filter_name,
+            },
+        };
+    }
+    if (data.category === ResponseCategory.Order &&
+        isApiOrderResponseAttributes(data.attributes)) {
+        return {
+            id: data.id,
+            createdAt: data.createdAt,
+            category: ResponseCategory.Order,
+            attributes: {
+                orderId: data.attributes.orderId,
+                orderNumber: data.attributes.orderNumber,
+                createdAt: data.attributes.created_at,
+                latestEventDate: data.attributes.latest_event_date,
+                lineItems: data.attributes.line_items.map((item) => {
+                    var _a, _b, _c, _d, _e;
+                    return ({
+                        itemTitle: item.item_title,
+                        itemPrice: item.item_price,
+                        itemQuantity: item.item_quantity,
+                        orderItemId: item.order_item_id,
+                        image: (_a = item.image) !== null && _a !== void 0 ? _a : undefined,
+                        inTransitAt: (_b = item.in_transit_at) !== null && _b !== void 0 ? _b : undefined,
+                        deliveredAt: (_c = item.delivered_at) !== null && _c !== void 0 ? _c : undefined,
+                        estimatedDeliveryAt: (_d = item.estimated_delivery_at) !== null && _d !== void 0 ? _d : undefined,
+                        fulfillmentDisplayStatus: item.fulfillment_display_status
+                            ? stringToFulfillmentDisplayStatusEnumValue(item.fulfillment_display_status)
+                            : undefined,
+                        trackingUrl: (_e = item.tracking_url) !== null && _e !== void 0 ? _e : undefined,
+                    });
+                }),
+            },
+        };
+    }
+    return undefined;
+};

package/dist/src/application/models/validators/validateSuggestion.js

@@ -0,0 +1,13 @@
+import { isSuggestion } from '../guards/api/isApiSuggestion';
+export const validateSuggestion = (data) => {
+    if (!isSuggestion(data)) {
+        return undefined;
+    }
+    return {
+        id: data.id,
+        category: data.category,
+        content: data.content,
+        createdAt: data.created_at,
+        isAnswer: data.is_answer,
+    };
+};

package/dist/src/application/models/validators/validateUserEvent.js

@@ -0,0 +1,91 @@
+import { UserEventCategory } from "@spiffy-ai/commerce-api-client";
+import { isApiUserEvent, isApiPDPAttributes, isApiQueryTypedAttributes, isApiSearchAttributes, isApiSuggestionClickedAttributes, } from "../guards/api";
+import { isApiFormSubmittedResponseAttributes } from "../guards/api/isApiFormSubmittedResponseAttributes";
+import { isApiPLPEventAttributes, isApiPLPIdAttribute, } from "../guards/api/isApiPLPEventAttributes";
+export const validateUserEvent = (data) => {
+    if (!isApiUserEvent(data)) {
+        return undefined;
+    }
+    if (data.category === UserEventCategory.PdpVisit &&
+        isApiPDPAttributes(data.attributes)) {
+        return {
+            eventId: data.event_id,
+            createdAt: data.created_at,
+            category: UserEventCategory.PdpVisit,
+            attributes: {
+                productId: data.attributes.product_id,
+                parentProductId: data.attributes.parent_product_id,
+                url: data.attributes.url,
+            },
+        };
+    }
+    if (data.category === UserEventCategory.QueryTyped &&
+        isApiQueryTypedAttributes(data.attributes)) {
+        return {
+            eventId: data.event_id,
+            createdAt: data.created_at,
+            category: UserEventCategory.QueryTyped,
+            attributes: {
+                query: data.attributes.query,
+            },
+        };
+    }
+    if (data.category === UserEventCategory.Search &&
+        isApiSearchAttributes(data.attributes)) {
+        return {
+            eventId: data.event_id,
+            createdAt: data.created_at,
+            category: UserEventCategory.Search,
+            attributes: {
+                searchTerm: data.attributes.search_term,
+                selectedFilters: data.attributes.selected_filters,
+            },
+        };
+    }
+    if (data.category === UserEventCategory.SuggestionClicked &&
+        isApiSuggestionClickedAttributes(data.attributes)) {
+        return {
+            eventId: data.event_id,
+            createdAt: data.created_at,
+            category: UserEventCategory.SuggestionClicked,
+            attributes: {
+                suggestionId: data.attributes.suggestion_id,
+            },
+        };
+    }
+    if (data.category === UserEventCategory.PlpVisit &&
+        isApiPLPEventAttributes(data.attributes)) {
+        if (isApiPLPIdAttribute(data.attributes)) {
+            return {
+                eventId: data.event_id,
+                createdAt: data.created_at,
+                category: UserEventCategory.PlpVisit,
+                attributes: {
+                    category: data.attributes.category,
+                    attributes: {
+                        id: data.attributes.id,
+                    },
+                },
+            };
+        }
+    }
+    if (data.category === UserEventCategory.FormSubmitted &&
+        isApiFormSubmittedResponseAttributes(data.attributes)) {
+        return {
+            eventId: data.event_id,
+            createdAt: data.created_at,
+            category: UserEventCategory.FormSubmitted,
+            attributes: {
+                filledSchema: { ...data.attributes.filled_schema },
+                formResponseId: data.attributes.form_response_id,
+                formType: data.attributes.form_type,
+            },
+        };
+    }
+    // we're not using app_unloaded at the moment so return the app_loaded event as default
+    return {
+        eventId: data.event_id,
+        createdAt: data.created_at,
+        category: UserEventCategory.AppLoaded,
+    };
+};

package/dist/src/application/utils/analyticsUtils.js

@@ -0,0 +1,95 @@
+import Logger from "src/application/logging/logger";
+import { isLegacyUAEcommerceEvent, isGA4EcommerceEvent, isBaseEcommerceEvent, } from "src/application/models";
+import { SpiffyMetricsEventName } from "@envive-ai/types";
+const NORMALIZED_ADD_TO_CART_EVENT_NAMES = ["addtocart", "addedtocart"];
+const CHECK_DATA_LAYER_INTERVAL_MS = 500;
+const CHECK_DATA_LAYER_MAX_ATTEMPTS = 10;
+/**
+ * Checks if a Google Analytics event is an add_to_cart event.
+ *
+ * @param event The event name to check.
+ *
+ * @returns True if the event is an add_to_cart event, false otherwise.
+ */
+const isAddToCartEvent = (event) => {
+    const normalizedEvent = event.replace(/[-_]/g, "").toLowerCase();
+    return NORMALIZED_ADD_TO_CART_EVENT_NAMES.some((name) => normalizedEvent.includes(name));
+};
+/**
+ * Tracks an add_to_cart event in Amplitude.
+ *
+ * @param event The event to track.
+ */
+const handleAddToCartEvent = (event, track) => {
+    let eventProps;
+    if (isLegacyUAEcommerceEvent(event)) {
+        eventProps = {
+            items: event.ecommerce.add.products.map((product) => ({
+                item_name: product.name,
+                item_category: product.category,
+                price: product.price,
+                quantity: product.quantity,
+            })),
+            currency: event.ecommerce.add.currencyCode,
+            event_format_version: "legacy_universal_analytics",
+        };
+    }
+    else if (isGA4EcommerceEvent(event)) {
+        eventProps = {
+            items: event.ecommerce.items.map((item) => ({
+                item_name: item.item_name,
+                item_category: item.item_category,
+                price: item.price,
+                quantity: item.quantity,
+            })),
+            currency: event.ecommerce.currency,
+            event_format_version: "google_analytics_4",
+        };
+    }
+    else {
+        eventProps = {
+            event_properties: { ...event },
+            event_format_version: "unknown",
+        };
+    }
+    track(SpiffyMetricsEventName.AddToCartClicked, {
+        eventProps,
+    });
+};
+/**
+ * Wraps the window.dataLayer.push method to intercept add_to_cart events and send them to Amplitude.
+ * This function runs on an interval until the dataLayer is available.
+ */
+export const initDataLayerWrapper = (track) => {
+    let attempts = 0;
+    // currently, our bundle is always loaded after GTM has initialized GA/dataLayer
+    // we'll need this check here if/when we load spiffy before/outside of GTM
+    const checkAndInitialize = () => {
+        if (!window.dataLayer || !window.dataLayer.push) {
+            attempts += 1;
+            if (attempts >= CHECK_DATA_LAYER_MAX_ATTEMPTS) {
+                Logger.logDebug(`[spiffy-ai] dataLayer not available after ${CHECK_DATA_LAYER_MAX_ATTEMPTS} attempts`);
+                return;
+            }
+            setTimeout(checkAndInitialize, CHECK_DATA_LAYER_INTERVAL_MS);
+            return;
+        }
+        Logger.logDebug("[spiffy-ai] dataLayer is available, wrapping push function...");
+        const originalPush = window.dataLayer.push;
+        window.dataLayer.push = (...args) => {
+            if (isBaseEcommerceEvent(args[0]) &&
+                isAddToCartEvent(args[0].event)) {
+                handleAddToCartEvent(args[0], track);
+            }
+            // IMPORTANT: call the original push method so that the event is still logged to GA
+            return originalPush.apply(window.dataLayer, args);
+        };
+    };
+    checkAndInitialize();
+};
+export const initAmplitude = (track) => {
+    // This function might not be needed anymore if Amplitude is initialized via context.
+    // For now, we'll keep it and pass the track function.
+    // If it's truly redundant, it can be removed later.
+    track(SpiffyMetricsEventName.BundleLoaded); // Example usage, adjust as needed
+};

package/dist/src/application/utils/coreContextToApiContext.js

@@ -0,0 +1,8 @@
+export const coreContextToApiContext = (context) => ({
+    chat_id: context.chatId,
+    org_id: context.orgId,
+    user_id: context.userId,
+    org_short_name: context.orgShortName,
+    source: context.source,
+    env: context.env,
+});

package/dist/src/application/utils/coreUserEventToApiUserEvent.js

@@ -0,0 +1,90 @@
+import { PLPAttributeCategory, UserEventCategory, } from '@spiffy-ai/commerce-api-client';
+export const coreUserEventToApiUserEvent = (data) => {
+    if (data.category === UserEventCategory.PdpVisit ||
+        data.category === UserEventCategory.AddToCart) {
+        return {
+            event_id: data.eventId,
+            created_at: data.createdAt,
+            category: data.category,
+            attributes: {
+                product_id: data.attributes.productId,
+                parent_product_id: data.attributes.parentProductId,
+                url: data.attributes.url,
+            },
+        };
+    }
+    if (data.category === UserEventCategory.PlpVisit) {
+        return {
+            event_id: data.eventId,
+            created_at: data.createdAt,
+            category: data.category,
+            attributes: {
+                category: PLPAttributeCategory.Id,
+                attributes: {
+                    // we're only handling id attributes for now
+                    id: data.attributes.attributes.id,
+                },
+            },
+        };
+    }
+    if (data.category === UserEventCategory.QueryTyped) {
+        return {
+            event_id: data.eventId,
+            created_at: data.createdAt,
+            category: data.category,
+            attributes: {
+                query: data.attributes.query,
+            },
+        };
+    }
+    if (data.category === UserEventCategory.Search) {
+        return {
+            event_id: data.eventId,
+            created_at: data.createdAt,
+            category: data.category,
+            attributes: {
+                search_term: data.attributes.searchTerm,
+                selected_filters: data.attributes.selectedFilters,
+            },
+        };
+    }
+    if (data.category === UserEventCategory.SuggestionClicked) {
+        return {
+            event_id: data.eventId,
+            created_at: data.createdAt,
+            category: data.category,
+            attributes: {
+                suggestion_id: data.attributes.suggestionId,
+            },
+        };
+    }
+    if (data.category === UserEventCategory.PageVisit) {
+        return {
+            event_id: data.eventId,
+            created_at: data.createdAt,
+            category: data.category,
+            attributes: {
+                url: data.attributes.url,
+                page_visit_category: data.attributes.pageVisitCategory,
+            },
+        };
+    }
+    if (data.category === UserEventCategory.FormSubmitted) {
+        return {
+            event_id: data.eventId,
+            created_at: data.createdAt,
+            category: data.category,
+            attributes: {
+                filled_schema: { ...data.attributes.filledSchema },
+                form_response_id: data.attributes.formResponseId,
+                form_type: data.attributes.formType,
+            },
+        };
+    }
+    // This is the default app_loaded event, when we start to use app_unloaded we need to handle it here
+    return {
+        event_id: data.eventId,
+        created_at: data.createdAt,
+        category: data.category,
+    };
+};

package/dist/src/application/utils/divideArray.js

@@ -0,0 +1,7 @@
+export const divideArray = (array, size) => {
+    const rows = [];
+    for (let i = 0; i < size; i += 1) {
+        rows.push(array.filter((_, index) => index % size === i));
+    }
+    return rows;
+};

package/dist/src/application/utils/domObserver.js

@@ -0,0 +1,85 @@
+import { ElementObserver } from './elementObserver';
+/**
+ * This class manages a `MutationObserver` for the `document.body`. It monitors nodes that are
+ * added or removed from the DOM and notifies the observers for each observable element
+ * when they are ready to be watched.
+ *
+ * How that works:
+ *
+ * When the `observe` function is called, it attaches a `MutationObserver` to the `document.body` element.
+ * All changes to `document.body` are tracked by this observer. When changes are detected, the `MutationObserver`
+ * iterates through all added and removed nodes and checks if each node exists in the main map of observable elements.
+ *
+ * If a match is found, it notifies the corresponding `ElementObserver` instance to start monitoring changes for that element.
+ *
+ * The primary `MutationObserver` remains active until the `destroy` function is called. Calling `destroy` will disconnect all
+ * individual element observers and release any associated resources.
+ *
+ * There is no need to explicitly call the `observe` function. It is automatically invoked when a `useElementObserver` hook is instantiated.
+ *
+ */
+export class DOMObserver {
+    static notifyAdition(records, nodeMapping) {
+        records.forEach((record) => record.addedNodes.forEach((node) => {
+            var _a;
+            (_a = nodeMapping.get(node)) === null || _a === void 0 ? void 0 : _a.watch(node);
+            nodeMapping.delete(node);
+        }));
+    }
+    static notifyRemoval(records, nodeMapping) {
+        records.forEach((record) => record.removedNodes.forEach((node) => {
+            var _a;
+            (_a = nodeMapping.get(node)) === null || _a === void 0 ? void 0 : _a.destroy();
+            nodeMapping.delete(node);
+        }));
+    }
+    static notifyChildrenChanges(nodeMapping) {
+        Array.from(nodeMapping.values()).forEach((observer) => observer.synchronize());
+    }
+    static mapNodeInstancesToListeners() {
+        const nodeMapping = new Map();
+        this.listeners.forEach((observer) => {
+            var _a;
+            const node = observer.getNode() || ((_a = observer.getSelector()) === null || _a === void 0 ? void 0 : _a.parse());
+            if (node) {
+                nodeMapping.set(node, observer);
+            }
+        });
+        return nodeMapping;
+    }
+    static add(selector) {
+        const node = selector.getPattern();
+        let elementObserver = this.listeners.get(node);
+        if (elementObserver) {
+            return elementObserver;
+        }
+        elementObserver = new ElementObserver(selector);
+        this.listeners.set(node, elementObserver);
+        return elementObserver;
+    }
+    static remove(selector) {
+        var _a;
+        const node = selector.getPattern();
+        (_a = this.listeners.get(node)) === null || _a === void 0 ? void 0 : _a.destroy();
+        this.listeners.delete(node);
+    }
+    static observe() {
+        if (!this.documentObserver) {
+            this.documentObserver = new MutationObserver((mutations) => {
+                const nodeMapping = this.mapNodeInstancesToListeners();
+                this.notifyAdition(mutations, nodeMapping);
+                this.notifyRemoval(mutations, nodeMapping);
+                this.notifyChildrenChanges(nodeMapping);
+            });
+            this.documentObserver.observe(document.body, { childList: true, subtree: true });
+        }
+    }
+    static destroy() {
+        var _a;
+        (_a = this.documentObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+        this.listeners.forEach((listener) => listener.destroy());
+        this.listeners.clear();
+        this.documentObserver = null;
+    }
+}
+DOMObserver.listeners = new Map();