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

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

@@ -0,0 +1,144 @@
+function isPlainObject(x) {
+    return (!!x &&
+        typeof x === 'object' &&
+        !Array.isArray(x) &&
+        !(x instanceof Date) &&
+        !(x instanceof RegExp));
+}
+function isReplace(x) {
+    return !!x && typeof x === 'object' && '$replace' in x;
+}
+function isDelete(x) {
+    return !!x && typeof x === 'object' && x.$delete === true;
+}
+function isPrimitiveValue(x) {
+    const t = typeof x;
+    return (x === null ||
+        t === 'string' ||
+        t === 'number' ||
+        t === 'boolean' ||
+        t === 'bigint' ||
+        t === 'symbol' ||
+        t === 'undefined');
+}
+function isArrayOfPrimitives(arr) {
+    if (arr.length === 0)
+        return false; // ambiguous, default to merge-by-index on empty
+    // If every defined element is primitive, treat as primitives
+    for (let i = 0; i < arr.length; i += 1) {
+        const v = arr[i];
+        if (v !== undefined && !isPrimitiveValue(v))
+            return false;
+    }
+    return true;
+}
+function mergeAny(baseAny, patchAny, opts) {
+    var _a;
+    if (isReplace(patchAny))
+        return patchAny.$replace;
+    if (isDelete(patchAny))
+        return undefined; // caller deletes the key
+    if (Array.isArray(baseAny)) {
+        if (Array.isArray(patchAny)) {
+            const baseArr = baseAny;
+            const patchArr = patchAny;
+            const shouldReplace = opts.arrayStrategy === 'replace' ||
+                isArrayOfPrimitives(baseArr) ||
+                isArrayOfPrimitives(patchArr);
+            if (shouldReplace)
+                return patchAny;
+            const out = baseArr.slice();
+            const max = Math.max(out.length, patchArr.length);
+            for (let i = 0; i < max; i += 1) {
+                const pVal = patchArr[i];
+                if (pVal !== undefined) {
+                    out[i] = mergeAny(out[i], pVal, opts);
+                }
+            }
+            return out;
+        }
+        return baseAny;
+    }
+    if (isPlainObject(baseAny) && isPlainObject(patchAny)) {
+        const baseObj = baseAny;
+        const patchObj = patchAny;
+        const out = { ...baseObj };
+        for (const key of Object.keys(patchObj)) {
+            const pVal = patchObj[key];
+            if (pVal === undefined) {
+                // leave as-is
+            }
+            else if (opts.nullDeletes && pVal === null) {
+                delete out[key];
+            }
+            else if (isReplace(pVal)) {
+                out[key] = pVal.$replace;
+            }
+            else if (isDelete(pVal)) {
+                delete out[key];
+            }
+            else {
+                out[key] = mergeAny(baseObj === null || baseObj === void 0 ? void 0 : baseObj[key], pVal, opts);
+            }
+        }
+        return out;
+    }
+    return (_a = patchAny) !== null && _a !== void 0 ? _a : baseAny;
+}
+export function applyOverrides(base, patch, opts = {}) {
+    var _a;
+    const { arrayStrategy = 'mergeByIndex', nullDeletes = false } = opts;
+    // Handle whole-node control operators on patch itself
+    if (isReplace(patch))
+        return patch.$replace;
+    if (isDelete(patch))
+        return undefined;
+    // Arrays
+    if (Array.isArray(base)) {
+        if (isReplace(patch))
+            return patch.$replace;
+        if (Array.isArray(patch)) {
+            if (arrayStrategy === 'replace')
+                return patch;
+            // merge by index
+            const out = base.slice();
+            const max = Math.max(out.length, patch.length);
+            for (let i = 0; i < max; i += 1) {
+                const pVal = patch[i];
+                if (pVal !== undefined) {
+                    out[i] = mergeAny(out[i], pVal, opts);
+                }
+            }
+            return out;
+        }
+        // invalid patch type for an array → ignore and return base
+        return base;
+    }
+    // Plain objects
+    if (isPlainObject(base) && isPlainObject(patch)) {
+        const out = { ...base };
+        const patchObj = patch;
+        for (const key of Object.keys(patchObj)) {
+            const pVal = patchObj[key];
+            if (pVal === undefined) {
+                // leave existing value
+            }
+            else if (nullDeletes && pVal === null) {
+                delete out[key];
+            }
+            else if (isReplace(pVal)) {
+                out[key] = pVal.$replace;
+            }
+            else if (isDelete(pVal)) {
+                delete out[key];
+            }
+            else {
+                const bVal = base[key];
+                out[key] = mergeAny(bVal, pVal, opts);
+            }
+        }
+        return out;
+    }
+    // For primitives or when patch is primitive, patch wins if defined
+    return ((_a = patch) !== null && _a !== void 0 ? _a : base);
+}

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

@@ -0,0 +1,47 @@
+class StringUtils {
+    static isNullOrEmpty(value) {
+        const valueTrimmed = value === null || value === void 0 ? void 0 : value.trim();
+        return value === undefined || valueTrimmed === '';
+    }
+    static trimToNull(value) {
+        const valueTrimmed = value === null || value === void 0 ? void 0 : value.trim();
+        return StringUtils.isNullOrEmpty(valueTrimmed) ? undefined : valueTrimmed;
+    }
+    static capitalize(type) {
+        if (type === undefined) {
+            return '';
+        }
+        return type.charAt(0).toUpperCase() + type.substring(1);
+    }
+    /**
+     * Finds the first pattern in an array that matches a given URL.
+     * Patterns can include a single wildcard '*' which matches any sequence of characters.
+     *
+     * @param patterns
+     * @param urlToTest
+     * @returns
+     */
+    static findMatchingPattern(patterns, urlToTest) {
+        if (!urlToTest) {
+            return undefined;
+        }
+        for (const pattern of patterns) {
+            // Test only if a pathname is present.
+            if (urlToTest.pathname !== '/') {
+                // Escape special regex characters in the pattern
+                // This ensures that characters like '.', '+', '?', '(', etc., in the pattern are treated literally.
+                const escapedPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+                // Replace the wildcard '*' with its regex equivalent '.*' (matches any character zero or more times)
+                const regexPattern = escapedPattern.replace(/\*/g, '.*');
+                const regex = new RegExp(`^${regexPattern}$`);
+                if (regex.test(urlToTest.pathname)) {
+                    return pattern;
+                }
+            }
+            else if (pattern.startsWith(urlToTest.hostname)) {
+                return pattern;
+            }
+        }
+    }
+}
+export { StringUtils };

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

@@ -0,0 +1,7 @@
+import { coreUserEventToApiUserEvent } from './coreUserEventToApiUserEvent';
+import { coreContextToApiContext } from './coreContextToApiContext';
+export const coreSupportedEventRequestToApiRequest = (coreSupportedEventRequest) => ({
+    id: coreSupportedEventRequest.id,
+    user_event: coreUserEventToApiUserEvent(coreSupportedEventRequest.userEvent),
+    context: coreContextToApiContext(coreSupportedEventRequest.context),
+});

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

@@ -0,0 +1,33 @@
+export const parseHref = (href) => {
+    try {
+        const url = new URL(href);
+        const urlSearchParams = new URLSearchParams(url.search);
+        return { url, urlSearchParams };
+    }
+    catch (e) {
+        return { url: undefined, urlSearchParams: undefined };
+    }
+};
+export const createUrlWithQueryParams = (url, queryParams) => {
+    const urlObj = new URL(url, window.location.href);
+    Object.entries(queryParams).forEach(([value, key]) => urlObj.searchParams.append(value, key));
+    return urlObj.href;
+};
+export const getQueryParam = (key) => {
+    const urlObj = new URL(window.location.href);
+    return urlObj.searchParams.get(key);
+};
+export const buildSearchHash = (message) => `#evs=true&s=${message.id}&q=${message.metadata.generatedQuery}`;
+export const buildSearchStartHash = (query) => `#evs=true&q=${query}`;
+// Basic parser for the search hash
+export const parseSearchHash = (hash) => {
+    if (!hash.startsWith('#evs=true')) {
+        return { id: null, query: null };
+    }
+    const params = Object.fromEntries(hash.split('&').map((param) => param.split('=')));
+    return {
+        id: params.s ? decodeURIComponent(params.s) : null,
+        query: params.q ? decodeURIComponent(params.q) : null,
+    };
+};
+window.history.pushState(null, '');

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

@@ -0,0 +1,5 @@
+// This email validates that there are one or more characters before the `@` symbol,
+// one or more characters between the `@` symbol and the `.` symbol,
+// and one or more characters after the `.` symbol
+// It does NOT validate all possible email formats, but it is a decent place to start.
+export const validateEmail = (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);

package/dist/src/atoms/amplitude/amplitudeTrackEventAtom.js

@@ -0,0 +1,4 @@
+import { atom } from "jotai";
+// This atom will hold the trackEvent function from the Amplitude context.
+// It needs to be initialized by a React component that has access to the useAmplitude hook.
+export const amplitudeTrackEventAtom = atom(null);

package/dist/src/atoms/app/index.js

@@ -0,0 +1,23 @@
+import { ContextSourceEnum } from '@spiffy-ai/commerce-api-client';
+import { atom } from 'jotai';
+import { atomWithStorage } from 'jotai/utils';
+import { useUserIdentity } from 'src/contexts/userIdentityContext/userIdentityContext';
+import { v4 as uuid } from 'uuid';
+import { contextSourceAtom } from '../envive/enviveConfig';
+export { variantInfoAtom } from './variant';
+const internalUserIdAtom = atom(undefined);
+export const userIdAtom = atom((get) => {
+    const maybeUserId = get(internalUserIdAtom);
+    if (maybeUserId) {
+        return maybeUserId;
+    }
+    const { getUserIdOrDefault } = useUserIdentity();
+    return getUserIdOrDefault();
+}, (_, set, value) => {
+    set(internalUserIdAtom, value);
+});
+export const userIdentityAtom = atom(undefined);
+export const appSourceAtom = atom((get) => { var _a; return (_a = get(contextSourceAtom)) !== null && _a !== void 0 ? _a : ContextSourceEnum.App; });
+export const chatIdAtom = atomWithStorage('v1-spiffy-chat-session-id', uuid(), undefined, {
+    getOnInit: true,
+});

package/dist/src/atoms/app/variant.js

@@ -0,0 +1,102 @@
+import { atomWithStorage } from 'jotai/utils';
+import { atom } from 'jotai';
+import { VariantTypeEnum, } from '@envive-ai/types';
+import { sessionStorageUtil } from 'src/atoms/atomStore';
+const internalStorageUrlResolverAtom = atomWithStorage('spiffy-url-resolver', undefined, sessionStorageUtil, {
+    getOnInit: true,
+});
+export const urlResolverAtom = atom((get) => {
+    const maybeUrlResolver = get(internalStorageUrlResolverAtom);
+    if (maybeUrlResolver == null) {
+        return {};
+    }
+    return JSON.parse(maybeUrlResolver);
+}, (get, set, value) => {
+    // Get current cache from storage
+    const currentCache = get(urlResolverAtom);
+    const newCache = { ...currentCache, [value.url]: value.response };
+    set(internalStorageUrlResolverAtom, JSON.stringify(newCache));
+});
+const internalStorageSupportedEventAtom = atomWithStorage('spiffy-supported-event', undefined, sessionStorageUtil, {
+    getOnInit: true,
+});
+const internalSupportedEventAtom = atom(undefined);
+export const supportedEventAtom = atom((get) => {
+    const maybeSupportedEvent = get(internalStorageSupportedEventAtom);
+    if (maybeSupportedEvent == null) {
+        return undefined;
+    }
+    // TODO this is an unvalidated parse. It may be better to implement a custom storage util
+    // and perform the object validation on "get" there.
+    return JSON.parse(maybeSupportedEvent);
+}, (_, set, value) => {
+    if (value == null) {
+        set(internalStorageSupportedEventAtom, undefined);
+        set(internalSupportedEventAtom, undefined);
+        return;
+    }
+    set(internalSupportedEventAtom, value);
+    set(internalStorageSupportedEventAtom, JSON.stringify(value));
+});
+const internalVariantIdAtom = atom();
+const internalProductIdAtom = atom();
+const internalParentProductIdAtom = atom();
+const internalProductUrlAtom = atom();
+const internalPlpIdAtom = atom();
+const internalUrlAtom = atom();
+const internalPageVisitCategoryAtom = atom();
+const internalVariantAtom = atom('pdp');
+export const variantIdAtom = atom((get) => get(internalVariantIdAtom));
+export const productIdAtom = atom((get) => get(internalProductIdAtom));
+export const parentProductIdAtom = atom((get) => get(internalParentProductIdAtom));
+export const productUrlAtom = atom((get) => get(internalProductUrlAtom));
+export const plpIdAtom = atom((get) => get(internalPlpIdAtom));
+export const urlAtom = atom((get) => get(internalUrlAtom));
+export const pageVisitCategoryAtom = atom((get) => get(internalPageVisitCategoryAtom));
+export const variantAtom = atom((get) => get(internalVariantAtom));
+export const hasParsedVariantInfoAtom = atom(false);
+export const variantInfoAtom = atom((get) => {
+    const variant = get(variantAtom);
+    if (variant === VariantTypeEnum.Pdp) {
+        return {
+            variantId: get(variantIdAtom),
+            variant,
+            productId: get(productIdAtom),
+            parentProductId: get(parentProductIdAtom),
+            url: get(urlAtom),
+        };
+    }
+    if (variant === VariantTypeEnum.Plp) {
+        return {
+            variantId: get(variantIdAtom),
+            variant,
+            plpId: get(plpIdAtom),
+            url: get(urlAtom),
+        };
+    }
+    if (variant === VariantTypeEnum.PageVisit) {
+        return {
+            variantId: get(variantIdAtom),
+            variant,
+            url: get(urlAtom),
+            pageVisitCategory: get(pageVisitCategoryAtom),
+        };
+    }
+    throw new Error('Invalid variantInfo details');
+}, (_, set, newVariant) => {
+    set(internalVariantAtom, newVariant.variant);
+    set(internalVariantIdAtom, newVariant.variantId);
+    if (newVariant.variant === VariantTypeEnum.Pdp) {
+        set(internalProductIdAtom, newVariant.productId);
+        set(internalParentProductIdAtom, newVariant.parentProductId);
+        set(internalUrlAtom, newVariant.url);
+    }
+    if (newVariant.variant === VariantTypeEnum.Plp) {
+        set(internalPlpIdAtom, newVariant.plpId);
+        set(internalUrlAtom, newVariant.url);
+    }
+    if (newVariant.variant === VariantTypeEnum.PageVisit) {
+        set(internalUrlAtom, newVariant.url);
+        set(internalPageVisitCategoryAtom, newVariant.pageVisitCategory);
+    }
+});

package/dist/src/atoms/atomStore/atomStore.js

@@ -0,0 +1,28 @@
+import { getDefaultStore } from 'jotai';
+import { createJSONStorage } from 'jotai/utils';
+let atomStore = null;
+export const getAtomStore = () => {
+    if (!atomStore) {
+        atomStore = getDefaultStore();
+    }
+    return atomStore;
+};
+/**
+ * @internal
+ *
+ * Sets the global atom store to be the provided store.
+ *
+ * @param store - The store to set the global atom store to.
+ */
+export const setAtomStoreForTesting = (store) => {
+    atomStore = store;
+};
+/**
+ * @internal
+ *
+ * Resets the global atom store to null
+ */
+export const resetAtomStore = () => {
+    atomStore = null;
+};
+export const sessionStorageUtil = createJSONStorage(() => sessionStorage);

package/dist/src/atoms/atomStore/index.js

@@ -0,0 +1 @@
+export * from "./atomStore";

package/dist/src/atoms/chat/chatState.js

@@ -0,0 +1,33 @@
+import { UserEventCategory } from '@spiffy-ai/commerce-api-client/dist/models/UserEventCategory';
+import { atom } from 'jotai';
+import { SpiffyMetricsEventName } from 'src/contexts/amplitudeContext/amplitudeContext';
+import { SpiffyEventName, } from '@envive-ai/types';
+export const userHasRepliedAtom = atom(false);
+export const replyEventCategoryAtom = atom(UserEventCategory.AppLoaded);
+export const userQueryAtom = atom();
+export const suggestionAtom = atom(undefined);
+export const askQuestionBtnClickedAtom = atom(false);
+export const messagesAtom = atom([]);
+export const userEventsAtom = atom([]);
+export const suggestionsAtom = atom([]);
+export const suggestionsLoadingAtom = atom(false);
+export const responseStreamingAtom = atom(false);
+export const chatIsOpenAtom = atom(false);
+export const requestFailureAtom = atom(false);
+export const formSubmitAtom = atom();
+export const chatOnToggleAtom = atom(null, (get, set, triggerLocation, track) => {
+    const isOpen = get(chatIsOpenAtom);
+    set(chatIsOpenAtom, !isOpen);
+    if (!isOpen) {
+        window.dispatchEvent(new CustomEvent(SpiffyEventName.WidgetOpen));
+        track === null || track === void 0 ? void 0 : track(SpiffyMetricsEventName.ChatComponentExpanded, {
+            message_metadata: {
+                trigger_location: triggerLocation,
+            },
+        });
+    }
+    else {
+        window.dispatchEvent(new CustomEvent(SpiffyEventName.WidgetClose));
+        track === null || track === void 0 ? void 0 : track(SpiffyMetricsEventName.ChatComponentCollapsed);
+    }
+});

package/dist/src/atoms/chat/form.js

@@ -0,0 +1,16 @@
+import { UserEventCategory } from '@spiffy-ai/commerce-api-client';
+import { atom } from 'jotai';
+import { v4 as uuid } from 'uuid';
+import { formSubmitAtom, replyEventCategoryAtom } from 'src/atoms/chat';
+import { queueUserEventAtom } from 'src/atoms/chat/messageQueue';
+export const handleFormSubmittedAtom = atom(null, (_, set, form) => {
+    set(replyEventCategoryAtom, UserEventCategory.FormSubmitted);
+    set(formSubmitAtom, form);
+    const formUserEvent = {
+        eventId: uuid(),
+        category: UserEventCategory.FormSubmitted,
+        createdAt: new Date().toISOString(),
+        attributes: form,
+    };
+    set(queueUserEventAtom, formUserEvent);
+});

package/dist/src/atoms/chat/index.js

@@ -0,0 +1,23 @@
+import { atom } from 'jotai';
+import { responseStreamingAtom, suggestionsLoadingAtom, messagesAtom, userQueryAtom, replyEventCategoryAtom, userHasRepliedAtom, askQuestionBtnClickedAtom, suggestionsAtom, chatIsOpenAtom, chatOnToggleAtom, userEventsAtom, suggestionAtom, } from './chatState';
+export * from './chatState';
+export * from './replies';
+export * from './performanceMetrics';
+export * from './form';
+export * from './suggestions';
+export * from './lastMessage';
+export * from './renderedWidgetRefs';
+export const chatAtom = atom((get) => ({
+    userHasReplied: get(userHasRepliedAtom),
+    replyEventCategory: get(replyEventCategoryAtom),
+    userQuery: get(userQueryAtom),
+    suggestion: get(suggestionAtom),
+    askQuestionBtnClicked: get(askQuestionBtnClickedAtom),
+    messages: get(messagesAtom),
+    userEvents: get(userEventsAtom),
+    suggestions: get(suggestionsAtom),
+    suggestionsLoading: get(suggestionsLoadingAtom),
+    responseStreaming: get(responseStreamingAtom),
+    isOpen: get(chatIsOpenAtom),
+    onToggle: get(chatOnToggleAtom),
+}));

package/dist/src/atoms/chat/lastMessage.js

@@ -0,0 +1,10 @@
+import { atom } from 'jotai';
+import { messagesAtom, userHasRepliedAtom } from 'src/atoms/chat';
+export const lastAssistantMessageAtom = atom((get) => {
+    const messages = get(messagesAtom);
+    const userHasReplied = get(userHasRepliedAtom);
+    if (messages.length > 0 && !userHasReplied) {
+        return messages[messages.length - 1];
+    }
+    return null;
+});

package/dist/src/atoms/chat/messageQueue.js

@@ -0,0 +1,68 @@
+import { atom } from 'jotai';
+import { v4 as uuid } from 'uuid';
+import { getAtomStore } from 'src/atoms/atomStore/atomStore';
+import { userIdAtom, chatIdAtom } from 'src/atoms/app';
+import { orgShortNameAtom, contextSourceAtom, envAtom } from 'src/atoms/envive/enviveConfig';
+import { orgIdAtom, featureFlagServiceAtom } from 'src/atoms/org/graphqlConfig';
+const internalUserEventQueueAtom = atom([]);
+export const userEventQueueAtom = atom((get) => {
+    const queue = get(internalUserEventQueueAtom);
+    return queue === undefined ? [] : queue.filter((v) => v !== undefined);
+});
+/**
+ * This atom is used to queue a new message for processing on `next_responses`
+ * It receives a single `userEvent` that is added to the processing queue.
+ * If the event has the same eventId as an existing message in the queue the NEW
+ * event is ignored
+ */
+export const queueUserEventAtom = atom(null, (get, set, userEvent) => {
+    if (userEvent === undefined) {
+        return;
+    }
+    set(internalUserEventQueueAtom, [...get(internalUserEventQueueAtom), userEvent]);
+});
+/**
+ * This atom exposes a function to reset the entire queue. All messages in the queue will be purged
+ */
+export const clearUserEventAtom = atom(null, (_, set) => {
+    set(internalUserEventQueueAtom, []);
+});
+/**
+ * This atom is used to mark events as processed and remove them from the queue
+ * It accepts a list of eventId values and will remove all events with those eventIds from the queue.
+ */
+export const processUserEventAtom = atom(null, (get, set, eventIds) => {
+    const curr = get(internalUserEventQueueAtom);
+    const remaining = curr === null || curr === void 0 ? void 0 : curr.filter((event) => !eventIds.includes(event.eventId));
+    set(internalUserEventQueueAtom, remaining);
+});
+export const userQueueEventCountAtom = atom((get) => get(userEventQueueAtom).length);
+import { ContextSourceEnum, ContextEnvEnum } from '@spiffy-ai/commerce-api-client'; // Import necessary enums
+// import type { Context } from "@spiffy-ai/commerce-api-client/dist/models/Context"; // Import Context type
+export const createResponsePayload = ({ userEvents, generationParams, }) => {
+    var _a, _b;
+    const atomStore = getAtomStore();
+    const orgShortName = atomStore.get(orgShortNameAtom);
+    const orgId = atomStore.get(orgIdAtom);
+    const userId = atomStore.get(userIdAtom);
+    const chatId = atomStore.get(chatIdAtom);
+    const source = atomStore.get(contextSourceAtom);
+    const env = atomStore.get(envAtom);
+    const featureFlagService = atomStore.get(featureFlagServiceAtom);
+    const context = {
+        userId: userId !== null && userId !== void 0 ? userId : '',
+        org_id: orgId !== null && orgId !== void 0 ? orgId : '',
+        org_short_name: orgShortName !== null && orgShortName !== void 0 ? orgShortName : '',
+        chat_id: chatId !== null && chatId !== void 0 ? chatId : '',
+        source: source !== null && source !== void 0 ? source : ContextSourceEnum.App,
+        env: (_a = env) !== null && _a !== void 0 ? _a : ContextEnvEnum.Dev,
+    };
+    const featureFlags = ((_b = featureFlagService === null || featureFlagService === void 0 ? void 0 : featureFlagService.featureFlagService) === null || _b === void 0 ? void 0 : _b.getFeatureFlags()) || {};
+    return {
+        id: uuid(),
+        context,
+        userEvents,
+        featureFlags: Object.fromEntries(Object.entries(featureFlags).filter(([, isEnabled]) => isEnabled)), // Convert back to Record<string, boolean>
+        generationParams,
+    };
+};

package/dist/src/atoms/chat/performanceMetrics.js

@@ -0,0 +1,70 @@
+var _a, _b;
+import { atom } from "jotai";
+import { atomWithStorage } from "jotai/utils";
+import Logger from "src/application/logging/logger";
+import { getAtomStore, sessionStorageUtil, } from "src/atoms/atomStore/atomStore";
+export const APP_INITIAL_START_TIME_KEY = "spiffy-app-initial-start-time";
+export const PAGE_LOAD_OFFSET_TIME_KEY = "spiffy-page-load-offset-time";
+/**
+ * The different performance metrics that can be logged. All times are relative to the
+ * initial start time of the app and are stored in milliseconds.
+ */
+export var PerfMetricsEvents;
+(function (PerfMetricsEvents) {
+    PerfMetricsEvents["PageLoadOffset"] = "page_load_offset_ms";
+    PerfMetricsEvents["MainBundleLoaded"] = "main_bundle_loaded_ms";
+    PerfMetricsEvents["OrgConfigLoadStarted"] = "org_config_load_started_ms";
+    PerfMetricsEvents["OrgConfigLoadEnded"] = "org_config_load_ended_ms";
+    PerfMetricsEvents["FirstResponseStarted"] = "first_response_started_ms";
+    PerfMetricsEvents["FirstResponseCompleted"] = "first_response_completed_ms";
+    PerfMetricsEvents["FirstSuggestionsStarted"] = "first_suggestions_started_ms";
+    PerfMetricsEvents["FirstSuggestionsCompleted"] = "first_suggestions_completed_ms";
+    PerfMetricsEvents["EmbeddedWidgetRendered"] = "embedded_widget_rendered_ms";
+    PerfMetricsEvents["FloatingButtonRendered"] = "floating_button_rendered_ms";
+    PerfMetricsEvents["TopSuggestionsBarRendered"] = "top_suggestions_bar_rendered_ms";
+    PerfMetricsEvents["BottomSuggestionsBarRendered"] = "bottom_suggestions_bar_rendered_ms";
+    PerfMetricsEvents["SearchPromptRendered"] = "search_prompt_rendered_ms";
+})(PerfMetricsEvents || (PerfMetricsEvents = {}));
+const internalPerfMetricsAtom = atom(new Map());
+export const appInitialStartTimeMsAtom = atomWithStorage(APP_INITIAL_START_TIME_KEY, (_a = sessionStorage.getItem(APP_INITIAL_START_TIME_KEY)) !== null && _a !== void 0 ? _a : undefined, sessionStorageUtil, {
+    getOnInit: true,
+});
+export const pageLoadOffsetTimeAtom = atomWithStorage(PAGE_LOAD_OFFSET_TIME_KEY, (_b = sessionStorage.getItem(PAGE_LOAD_OFFSET_TIME_KEY)) !== null && _b !== void 0 ? _b : undefined, sessionStorageUtil, {
+    getOnInit: true,
+});
+/**
+ * Resets the performance metrics atom to an empty map. This should be called after the performance
+ * metrics have been reported to amplitude. On SPA, it ensures that we can still capture metrics as
+ * the user navigates around the app (although there is more work to be done to fully enable this).
+ * On non-SPA, it ensures that previously captured metrics are not reported again.
+ */
+export const resetPerformanceMetricsAtom = () => {
+    const atomStore = getAtomStore();
+    atomStore.set(internalPerfMetricsAtom, new Map());
+};
+export const performanceMetricsAtom = atom((get) => get(internalPerfMetricsAtom));
+export const hasReportedPerformanceMetricsAtom = atom(false);
+/**
+ * Logs a performance metric by capturing the delta between the initial app start time
+ * and the current time. If the metric has already been logged, it will not be logged again.
+ *
+ * @param value The performance metric name to log.
+ */
+export const logPerfMetricAtom = atom(null, (get, set, value) => {
+    const initialTimeStorageValue = get(appInitialStartTimeMsAtom);
+    const initialTimeMs = initialTimeStorageValue
+        ? parseInt(initialTimeStorageValue, 10)
+        : undefined;
+    if (initialTimeMs == null) {
+        Logger.logWarn(`[spiffy-ai] No initial app start time found. Skipping...`, undefined);
+        return;
+    }
+    const currentPerfMetrics = get(internalPerfMetricsAtom);
+    if (currentPerfMetrics.has(value)) {
+        return;
+    }
+    const currentTimeMs = Date.now();
+    const deltaMs = currentTimeMs - initialTimeMs;
+    currentPerfMetrics.set(value, deltaMs);
+    set(internalPerfMetricsAtom, currentPerfMetrics);
+});

package/dist/src/atoms/chat/renderedWidgetRefs.js

@@ -0,0 +1,24 @@
+import { atom } from "jotai";
+import { getAtomStore } from "src/atoms/atomStore/atomStore";
+const internalWidgetArrayAtom = atom([]);
+export const widgetArrayAtom = atom((get) => get(internalWidgetArrayAtom));
+/**
+ * This function call is used to create a list of the Spiffy widgets
+ * that are rendering on the page.
+ *
+ * It is used by the FloatingButton widget to slide out of view when it
+ * overlaps with another Spiffy widget.
+ *
+ * The spiffy widgets should be added to the this array for the floating button
+ * to know about them.
+ *
+ * Today the "SuggestionBar" widget is not added, but the other widgets are.
+ *
+ */
+export const addWidget = (ref, idx) => {
+    const atomStore = getAtomStore();
+    const val = atomStore.get(internalWidgetArrayAtom);
+    const insertIdx = idx !== null && idx !== void 0 ? idx : val.length;
+    val[insertIdx] = ref;
+    atomStore.set(internalWidgetArrayAtom, val);
+};