@envive-ai/react-hooks 0.2.6-alpha → 0.2.6-alpha-2

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

@@ -1,173 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,94 +0,0 @@
-import Logger from 'src/application/logging/logger';
-import { isLegacyUAEcommerceEvent, isGA4EcommerceEvent, isBaseEcommerceEvent, } from 'src/application/models';
-import { SpiffyMetricsEventName } from 'src/contexts/amplitudeContext/amplitudeContext';
-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

@@ -1,8 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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();