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

package/dist/chat-C5afTKUY.js

@@ -0,0 +1,226 @@
+import { MessageType as MessageType$1, SpiffyMetricsEventName } from "./dist-C38adNK1.js";
+import { MessageRole, MessageType } from "./types-y3mhxOUA.js";
+import { logger_default } from "./logger-BMVdhQOV.js";
+import { getAtomStore, sessionStorageUtil } from "./atomStore-CfzCqWB9.js";
+import { askQuestionBtnClickedAtom, chatIsOpenAtom, chatOnToggleAtom, formSubmitAtom, messagesAtom, replyEventCategoryAtom, responseStreamingAtom, suggestionAtom, suggestionsAtom, suggestionsLoadingAtom, userEventsAtom, userHasRepliedAtom, userQueryAtom } from "./chatState-BbI93m6r.js";
+import { amplitudeTrackEventAtom } from "./amplitudeTrackEventAtom-D66l5oFp.js";
+import { ContextEnvEnum, ContextSourceEnum, UserEventCategory } from "@spiffy-ai/commerce-api-client";
+import { v4 } from "uuid";
+import { atom } from "jotai";
+import { atomWithStorage } from "jotai/utils";
+
+//#region src/atoms/chat/messageQueue.ts
+const internalUserEventQueueAtom = atom([]);
+const userEventQueueAtom = atom((get) => {
+	const queue = get(internalUserEventQueueAtom);
+	return queue === void 0 ? [] : queue.filter((v) => v !== void 0);
+});
+/**
+* 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
+*/
+const queueUserEventAtom = atom(null, (get, set, userEvent) => {
+	if (userEvent === void 0) return;
+	set(internalUserEventQueueAtom, [...get(internalUserEventQueueAtom), userEvent]);
+});
+/**
+* This atom exposes a function to reset the entire queue. All messages in the queue will be purged
+*/
+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.
+*/
+const processUserEventAtom = atom(null, (get, set, eventIds) => {
+	const remaining = get(internalUserEventQueueAtom)?.filter((event) => !eventIds.includes(event.eventId));
+	set(internalUserEventQueueAtom, remaining);
+});
+const userQueueEventCountAtom = atom((get) => get(userEventQueueAtom).length);
+
+//#endregion
+//#region src/atoms/chat/replies.ts
+const handleReplyAtom = atom(null, (get, set, { message, userTyped }) => {
+	if (message.type !== MessageType$1.QueryTyped) return;
+	const trackEvent = get(amplitudeTrackEventAtom);
+	const queryTyped = message.metadata.content;
+	set(replyEventCategoryAtom, UserEventCategory.QueryTyped);
+	set(userQueryAtom, queryTyped);
+	set(messagesAtom, [...get(messagesAtom), [message]]);
+	set(userHasRepliedAtom, true);
+	set(queueUserEventAtom, {
+		eventId: message.id,
+		createdAt: message.createdAt,
+		category: UserEventCategory.QueryTyped,
+		attributes: { query: queryTyped }
+	});
+	if (trackEvent) trackEvent({
+		eventName: SpiffyMetricsEventName.ChatUserMessageInput,
+		eventProps: {
+			message_id: message.id,
+			message_role: message.role,
+			message_type: message.type,
+			message_metadata: {
+				content: message?.metadata?.content,
+				created_at: message.createdAt,
+				user_typed: userTyped
+			}
+		},
+		alsoSendToGoogleAnalytics: true
+	});
+});
+
+//#endregion
+//#region src/atoms/chat/performanceMetrics.ts
+const APP_INITIAL_START_TIME_KEY = "spiffy-app-initial-start-time";
+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.
+*/
+let PerfMetricsEvents = /* @__PURE__ */ function(PerfMetricsEvents$1) {
+	PerfMetricsEvents$1["PageLoadOffset"] = "page_load_offset_ms";
+	PerfMetricsEvents$1["MainBundleLoaded"] = "main_bundle_loaded_ms";
+	PerfMetricsEvents$1["OrgConfigLoadStarted"] = "org_config_load_started_ms";
+	PerfMetricsEvents$1["OrgConfigLoadEnded"] = "org_config_load_ended_ms";
+	PerfMetricsEvents$1["FirstResponseStarted"] = "first_response_started_ms";
+	PerfMetricsEvents$1["FirstResponseCompleted"] = "first_response_completed_ms";
+	PerfMetricsEvents$1["FirstSuggestionsStarted"] = "first_suggestions_started_ms";
+	PerfMetricsEvents$1["FirstSuggestionsCompleted"] = "first_suggestions_completed_ms";
+	PerfMetricsEvents$1["EmbeddedWidgetRendered"] = "embedded_widget_rendered_ms";
+	PerfMetricsEvents$1["FloatingButtonRendered"] = "floating_button_rendered_ms";
+	PerfMetricsEvents$1["TopSuggestionsBarRendered"] = "top_suggestions_bar_rendered_ms";
+	PerfMetricsEvents$1["BottomSuggestionsBarRendered"] = "bottom_suggestions_bar_rendered_ms";
+	PerfMetricsEvents$1["SearchPromptRendered"] = "search_prompt_rendered_ms";
+	return PerfMetricsEvents$1;
+}({});
+const internalPerfMetricsAtom = atom(/* @__PURE__ */ new Map());
+const appInitialStartTimeMsAtom = atomWithStorage(APP_INITIAL_START_TIME_KEY, sessionStorage.getItem(APP_INITIAL_START_TIME_KEY) ?? void 0, sessionStorageUtil, { getOnInit: true });
+const pageLoadOffsetTimeAtom = atomWithStorage(PAGE_LOAD_OFFSET_TIME_KEY, sessionStorage.getItem(PAGE_LOAD_OFFSET_TIME_KEY) ?? void 0, 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.
+*/
+const resetPerformanceMetricsAtom = () => {
+	getAtomStore().set(internalPerfMetricsAtom, /* @__PURE__ */ new Map());
+};
+const performanceMetricsAtom = atom((get) => get(internalPerfMetricsAtom));
+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.
+*/
+const logPerfMetricAtom = atom(null, (get, set, value) => {
+	const initialTimeStorageValue = get(appInitialStartTimeMsAtom);
+	const initialTimeMs = initialTimeStorageValue ? parseInt(initialTimeStorageValue, 10) : void 0;
+	if (initialTimeMs == null) {
+		logger_default.logWarn(`[spiffy-ai] No initial app start time found. Skipping...`, void 0);
+		return;
+	}
+	const currentPerfMetrics = get(internalPerfMetricsAtom);
+	if (currentPerfMetrics.has(value)) return;
+	const deltaMs = Date.now() - initialTimeMs;
+	currentPerfMetrics.set(value, deltaMs);
+	set(internalPerfMetricsAtom, currentPerfMetrics);
+});
+
+//#endregion
+//#region src/atoms/chat/form.ts
+const handleFormSubmittedAtom = atom(null, (_, set, form) => {
+	set(replyEventCategoryAtom, UserEventCategory.FormSubmitted);
+	set(formSubmitAtom, form);
+	const formUserEvent = {
+		eventId: v4(),
+		category: UserEventCategory.FormSubmitted,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		attributes: form
+	};
+	set(queueUserEventAtom, formUserEvent);
+});
+
+//#endregion
+//#region src/atoms/chat/suggestions.ts
+const handleSuggestionAtom = atom(null, (get, set, suggestion) => {
+	const newMessage = {
+		id: suggestion.id,
+		role: MessageRole.User,
+		type: MessageType.SuggestionClicked,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		metadata: {
+			suggestionId: suggestion.id,
+			suggestionContent: suggestion.content
+		}
+	};
+	set(replyEventCategoryAtom, UserEventCategory.SuggestionClicked);
+	set(suggestionAtom, suggestion);
+	set(messagesAtom, [...get(messagesAtom), [newMessage]]);
+	set(userHasRepliedAtom, true);
+	set(queueUserEventAtom, {
+		eventId: suggestion.id,
+		category: UserEventCategory.SuggestionClicked,
+		createdAt: newMessage.createdAt,
+		attributes: { suggestionId: suggestion.id }
+	});
+});
+
+//#endregion
+//#region src/atoms/chat/lastMessage.ts
+const lastAssistantMessageAtom = atom((get) => {
+	const messages = get(messagesAtom);
+	const userHasReplied = get(userHasRepliedAtom);
+	if (messages.length > 0 && !userHasReplied) return messages[messages.length - 1];
+	return null;
+});
+
+//#endregion
+//#region src/atoms/chat/renderedWidgetRefs.ts
+const internalWidgetArrayAtom = atom([]);
+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.
+*
+*/
+const addWidget = (ref, idx) => {
+	const atomStore = getAtomStore();
+	const val = atomStore.get(internalWidgetArrayAtom);
+	const insertIdx = idx ?? val.length;
+	val[insertIdx] = ref;
+	atomStore.set(internalWidgetArrayAtom, val);
+};
+
+//#endregion
+//#region src/atoms/chat/index.ts
+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)
+}));
+
+//#endregion
+export { APP_INITIAL_START_TIME_KEY, PAGE_LOAD_OFFSET_TIME_KEY, PerfMetricsEvents, addWidget, appInitialStartTimeMsAtom, chatAtom, handleFormSubmittedAtom, handleReplyAtom, handleSuggestionAtom, hasReportedPerformanceMetricsAtom, lastAssistantMessageAtom, logPerfMetricAtom, pageLoadOffsetTimeAtom, performanceMetricsAtom, resetPerformanceMetricsAtom, widgetArrayAtom };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"chat-C5afTKUY.js","names":["MessageType","uuid","newMessage: Message"],"sources":["../src/atoms/chat/messageQueue.ts","../src/atoms/chat/replies.ts","../src/atoms/chat/performanceMetrics.ts","../src/atoms/chat/form.ts","../src/atoms/chat/suggestions.ts","../src/atoms/chat/lastMessage.ts","../src/atoms/chat/renderedWidgetRefs.ts","../src/atoms/chat/index.ts"],"sourcesContent":["import { atom } from 'jotai';\nimport { v4 as uuid } from 'uuid';\nimport { GenerationParams, NextMessageRequest, UserEvent } from '@envive-ai/types';\nimport { getAtomStore } from 'src/atoms/atomStore/atomStore';\nimport { userIdAtom, chatIdAtom } from 'src/atoms/app';\nimport { orgShortNameAtom, contextSourceAtom, envAtom } from 'src/atoms/envive/enviveConfig';\nimport { orgIdAtom, featureFlagServiceAtom } from 'src/atoms/org/graphqlConfig';\n\nconst internalUserEventQueueAtom = atom<UserEvent[]>([]);\n\nexport const userEventQueueAtom = atom((get) => {\n  const queue = get(internalUserEventQueueAtom);\n  return queue === undefined ? [] : queue.filter((v) => v !== undefined);\n});\n\n/**\n * This atom is used to queue a new message for processing on `next_responses`\n * It receives a single `userEvent` that is added to the processing queue.\n * If the event has the same eventId as an existing message in the queue the NEW\n * event is ignored\n */\nexport const queueUserEventAtom = atom(null, (get, set, userEvent: UserEvent) => {\n  if (userEvent === undefined) {\n    return;\n  }\n  set(internalUserEventQueueAtom, [...get(internalUserEventQueueAtom), userEvent]);\n});\n\n/**\n * This atom exposes a function to reset the entire queue. All messages in the queue will be purged\n */\nexport const clearUserEventAtom = atom(null, (_, set) => {\n  set(internalUserEventQueueAtom, []);\n});\n\n/**\n * This atom is used to mark events as processed and remove them from the queue\n * It accepts a list of eventId values and will remove all events with those eventIds from the queue.\n */\nexport const processUserEventAtom = atom(null, (get, set, eventIds: string[]) => {\n  const curr = get(internalUserEventQueueAtom);\n  const remaining = curr?.filter((event) => !eventIds.includes(event.eventId));\n  set(internalUserEventQueueAtom, remaining);\n});\n\nexport const userQueueEventCountAtom = atom((get) => get(userEventQueueAtom).length);\n\nimport { ContextSourceEnum, ContextEnvEnum } from '@spiffy-ai/commerce-api-client'; // Import necessary enums\n// import type { Context } from \"@spiffy-ai/commerce-api-client/dist/models/Context\"; // Import Context type\n\nexport const createResponsePayload = ({\n  userEvents,\n  generationParams,\n}: {\n  userEvents: UserEvent[];\n  generationParams?: GenerationParams;\n}): NextMessageRequest => {\n  const atomStore = getAtomStore();\n  const orgShortName = atomStore.get(orgShortNameAtom);\n  const orgId = atomStore.get(orgIdAtom);\n  const userId = atomStore.get(userIdAtom);\n  const chatId = atomStore.get(chatIdAtom);\n  const source = atomStore.get(contextSourceAtom);\n  const env = atomStore.get(envAtom);\n\n  const featureFlagService = atomStore.get(featureFlagServiceAtom);\n\n  const context = {\n    userId: userId ?? '',\n    org_id: orgId ?? '',\n    org_short_name: orgShortName ?? '',\n    chat_id: chatId ?? '',\n    source: source ?? ContextSourceEnum.App,\n    env: (env as ContextEnvEnum) ?? ContextEnvEnum.Dev,\n  };\n\n  const featureFlags = featureFlagService?.featureFlagService?.getFeatureFlags() || {};\n\n  return {\n    id: uuid(),\n    context,\n    userEvents,\n    featureFlags: Object.fromEntries(\n      Object.entries(featureFlags).filter(([, isEnabled]) => isEnabled),\n    ), // Convert back to Record<string, boolean>\n    generationParams,\n  };\n};\n","import { atom } from \"jotai\";\nimport { Message, MessageType, SpiffyMetricsEventName } from \"@envive-ai/types\";\nimport {\n  userHasRepliedAtom,\n  messagesAtom,\n  userQueryAtom,\n  replyEventCategoryAtom,\n} from \"src/atoms/chat\";\nimport { UserEventCategory } from \"@spiffy-ai/commerce-api-client\";\nimport { queueUserEventAtom } from \"./messageQueue\";\nimport { amplitudeTrackEventAtom } from \"src/atoms/amplitude/amplitudeTrackEventAtom\";\n\ntype HandleReplyParams = {\n  message: Message;\n  userTyped: boolean;\n};\n\nexport const handleReplyAtom = atom(\n  null,\n  (get, set, { message, userTyped }: HandleReplyParams) => {\n    if (message.type !== MessageType.QueryTyped) {\n      return;\n    }\n\n    const trackEvent = get(amplitudeTrackEventAtom);\n    const queryTyped = message.metadata.content;\n\n    set(replyEventCategoryAtom, UserEventCategory.QueryTyped);\n    set(userQueryAtom, queryTyped);\n    set(messagesAtom, [...get(messagesAtom), [message]]);\n    set(userHasRepliedAtom, true);\n    set(queueUserEventAtom, {\n      eventId: message.id,\n      createdAt: message.createdAt,\n      category: UserEventCategory.QueryTyped,\n      attributes: {\n        query: queryTyped,\n      },\n    });\n\n    if (trackEvent) {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.ChatUserMessageInput,\n        eventProps: {\n          message_id: message.id,\n          message_role: message.role,\n          message_type: message.type,\n          message_metadata: {\n            content: message?.metadata?.content, // Removed amplitudeSafeString\n            created_at: message.createdAt,\n            user_typed: userTyped,\n          },\n        },\n        alsoSendToGoogleAnalytics: true,\n      });\n    }\n  }\n);\n","import { atom } from \"jotai\";\nimport { atomWithStorage } from \"jotai/utils\";\nimport Logger from \"src/application/logging/logger\";\nimport {\n  getAtomStore,\n  sessionStorageUtil,\n} from \"src/atoms/atomStore/atomStore\";\n\nexport const APP_INITIAL_START_TIME_KEY = \"spiffy-app-initial-start-time\";\nexport const PAGE_LOAD_OFFSET_TIME_KEY = \"spiffy-page-load-offset-time\";\n/**\n * The different performance metrics that can be logged. All times are relative to the\n * initial start time of the app and are stored in milliseconds.\n */\nexport enum PerfMetricsEvents {\n  PageLoadOffset = \"page_load_offset_ms\",\n  MainBundleLoaded = \"main_bundle_loaded_ms\",\n  OrgConfigLoadStarted = \"org_config_load_started_ms\",\n  OrgConfigLoadEnded = \"org_config_load_ended_ms\",\n  FirstResponseStarted = \"first_response_started_ms\",\n  FirstResponseCompleted = \"first_response_completed_ms\",\n  FirstSuggestionsStarted = \"first_suggestions_started_ms\",\n  FirstSuggestionsCompleted = \"first_suggestions_completed_ms\",\n  EmbeddedWidgetRendered = \"embedded_widget_rendered_ms\",\n  FloatingButtonRendered = \"floating_button_rendered_ms\",\n  TopSuggestionsBarRendered = \"top_suggestions_bar_rendered_ms\",\n  BottomSuggestionsBarRendered = \"bottom_suggestions_bar_rendered_ms\",\n  SearchPromptRendered = \"search_prompt_rendered_ms\",\n}\n\nconst internalPerfMetricsAtom = atom<Map<PerfMetricsEvents, number>>(new Map());\nexport const appInitialStartTimeMsAtom = atomWithStorage<string | undefined>(\n  APP_INITIAL_START_TIME_KEY,\n  sessionStorage.getItem(APP_INITIAL_START_TIME_KEY) ?? undefined,\n  sessionStorageUtil,\n  {\n    getOnInit: true,\n  }\n);\n\nexport const pageLoadOffsetTimeAtom = atomWithStorage<string | undefined>(\n  PAGE_LOAD_OFFSET_TIME_KEY,\n  sessionStorage.getItem(PAGE_LOAD_OFFSET_TIME_KEY) ?? undefined,\n  sessionStorageUtil,\n  {\n    getOnInit: true,\n  }\n);\n\n/**\n * Resets the performance metrics atom to an empty map. This should be called after the performance\n * metrics have been reported to amplitude. On SPA, it ensures that we can still capture metrics as\n * the user navigates around the app (although there is more work to be done to fully enable this).\n * On non-SPA, it ensures that previously captured metrics are not reported again.\n */\nexport const resetPerformanceMetricsAtom = () => {\n  const atomStore = getAtomStore();\n  atomStore.set(internalPerfMetricsAtom, new Map());\n};\nexport const performanceMetricsAtom = atom((get) =>\n  get(internalPerfMetricsAtom)\n);\nexport const hasReportedPerformanceMetricsAtom = atom<boolean>(false);\n\n/**\n * Logs a performance metric by capturing the delta between the initial app start time\n * and the current time. If the metric has already been logged, it will not be logged again.\n *\n * @param value The performance metric name to log.\n */\nexport const logPerfMetricAtom = atom(\n  null,\n  (get, set, value: PerfMetricsEvents) => {\n    const initialTimeStorageValue = get(appInitialStartTimeMsAtom);\n    const initialTimeMs = initialTimeStorageValue\n      ? parseInt(initialTimeStorageValue, 10)\n      : undefined;\n\n    if (initialTimeMs == null) {\n      Logger.logWarn(\n        `[spiffy-ai] No initial app start time found. Skipping...`,\n        undefined\n      );\n      return;\n    }\n\n    const currentPerfMetrics = get(internalPerfMetricsAtom);\n    if (currentPerfMetrics.has(value)) {\n      return;\n    }\n\n    const currentTimeMs = Date.now();\n    const deltaMs = currentTimeMs - initialTimeMs;\n    currentPerfMetrics.set(value, deltaMs);\n    set(internalPerfMetricsAtom, currentPerfMetrics);\n  }\n);\n","import { UserEventCategory } from '@spiffy-ai/commerce-api-client';\nimport { atom } from 'jotai';\nimport { FormSubmittedAttributes, UserEvent } from '@envive-ai/types';\nimport { v4 as uuid } from 'uuid';\nimport { formSubmitAtom, replyEventCategoryAtom } from 'src/atoms/chat';\nimport { queueUserEventAtom } from 'src/atoms/chat/messageQueue';\n\nexport const handleFormSubmittedAtom = atom(null, (_, set, form: FormSubmittedAttributes) => {\n  set(replyEventCategoryAtom, UserEventCategory.FormSubmitted);\n  set(formSubmitAtom, form);\n\n  const formUserEvent = {\n    eventId: uuid(),\n    category: UserEventCategory.FormSubmitted,\n    createdAt: new Date().toISOString(),\n    attributes: form,\n  } satisfies UserEvent;\n  set(queueUserEventAtom, formUserEvent);\n});\n","import { atom } from \"jotai\";\nimport { Message, MessageRole, MessageType, Suggestion } from \"src/types\";\nimport {\n  messagesAtom,\n  replyEventCategoryAtom,\n  suggestionAtom,\n  userHasRepliedAtom,\n} from \"src/atoms/chat\";\nimport { FilterAttribute, ProductResponseAttributes } from \"src/types\";\n\nimport { UserEventCategory } from \"@spiffy-ai/commerce-api-client\";\nimport { queueUserEventAtom } from \"./messageQueue\";\n\nexport const handleSuggestionAtom = atom(\n  null,\n  (get, set, suggestion: Suggestion) => {\n    const newMessage: Message = {\n      id: suggestion.id,\n      role: MessageRole.User,\n      type: MessageType.SuggestionClicked,\n      createdAt: new Date().toISOString(),\n      metadata: {\n        suggestionId: suggestion.id,\n        suggestionContent: suggestion.content,\n      },\n    };\n\n    set(replyEventCategoryAtom, UserEventCategory.SuggestionClicked);\n    set(suggestionAtom, suggestion);\n    set(messagesAtom, [...get(messagesAtom), [newMessage]]);\n    set(userHasRepliedAtom, true);\n    set(queueUserEventAtom, {\n      eventId: suggestion.id,\n      category: UserEventCategory.SuggestionClicked,\n      createdAt: newMessage.createdAt,\n      attributes: {\n        suggestionId: suggestion.id,\n      },\n    });\n  }\n);\n","import { atom } from 'jotai';\nimport { messagesAtom, userHasRepliedAtom } from 'src/atoms/chat';\n\nexport const lastAssistantMessageAtom = atom((get) => {\n  const messages = get(messagesAtom);\n  const userHasReplied = get(userHasRepliedAtom);\n  if (messages.length > 0 && !userHasReplied) {\n    return messages[messages.length - 1];\n  }\n  return null;\n});\n","import { atom } from \"jotai\";\nimport { getAtomStore } from \"src/atoms/atomStore/atomStore\";\n\nconst internalWidgetArrayAtom = atom<HTMLElement[]>([]);\n\nexport const widgetArrayAtom = atom((get) => get(internalWidgetArrayAtom));\n\n/**\n * This function call is used to create a list of the Spiffy widgets\n * that are rendering on the page.\n *\n * It is used by the FloatingButton widget to slide out of view when it\n * overlaps with another Spiffy widget.\n *\n * The spiffy widgets should be added to the this array for the floating button\n * to know about them.\n *\n * Today the \"SuggestionBar\" widget is not added, but the other widgets are.\n *\n */\nexport const addWidget = (ref: HTMLElement, idx?: number) => {\n  const atomStore = getAtomStore();\n  const val = atomStore.get(internalWidgetArrayAtom);\n  const insertIdx = idx ?? val.length;\n  val[insertIdx] = ref;\n  atomStore.set(internalWidgetArrayAtom, val);\n};\n","import { atom } from 'jotai';\nimport {\n  responseStreamingAtom,\n  suggestionsLoadingAtom,\n  messagesAtom,\n  userQueryAtom,\n  replyEventCategoryAtom,\n  userHasRepliedAtom,\n  askQuestionBtnClickedAtom,\n  suggestionsAtom,\n  chatIsOpenAtom,\n  chatOnToggleAtom,\n  userEventsAtom,\n  suggestionAtom,\n} from './chatState';\n\nexport * from './chatState';\nexport * from './replies';\nexport * from './performanceMetrics';\nexport * from './form';\nexport * from './suggestions';\nexport * from './lastMessage';\nexport * from './renderedWidgetRefs';\n\nexport const chatAtom = atom((get) => ({\n  userHasReplied: get(userHasRepliedAtom),\n  replyEventCategory: get(replyEventCategoryAtom),\n  userQuery: get(userQueryAtom),\n  suggestion: get(suggestionAtom),\n  askQuestionBtnClicked: get(askQuestionBtnClickedAtom),\n  messages: get(messagesAtom),\n  userEvents: get(userEventsAtom),\n  suggestions: get(suggestionsAtom),\n  suggestionsLoading: get(suggestionsLoadingAtom),\n  responseStreaming: get(responseStreamingAtom),\n  isOpen: get(chatIsOpenAtom),\n  onToggle: get(chatOnToggleAtom),\n}));\n"],"mappings":"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"}

package/dist/{chat-BJL3nXR7.cjs → chat-CCjM6fS_.cjs}

@@ -1,11 +1,10 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_dist = require('./dist-BZX_Mgfn.cjs');
+const require_dist = require('./dist-VxRI6eQv.cjs');
 const require_types = require('./types-B8HZYWV3.cjs');
 const require_logger = require('./logger-BqHq67zN.cjs');
-const require_atomStore = require('./atomStore-CZKe3itM.cjs');
-const require_utils = require('./utils-DqxtxrFe.cjs');
-const require_chatState = require('./chatState-BYB77nbx.cjs');
-const require_amplitudeTrackEventAtom = require('./amplitudeTrackEventAtom-D9vs8dpE.cjs');
+const require_atomStore = require('./atomStore-BQVO5haU.cjs');
+const require_chatState = require('./chatState-DlJpHAsW.cjs');
+const require_amplitudeTrackEventAtom = require('./amplitudeTrackEventAtom-f22P2U0u.cjs');
 let __spiffy_ai_commerce_api_client = require("@spiffy-ai/commerce-api-client");
 __spiffy_ai_commerce_api_client = require_chunk.__toESM(__spiffy_ai_commerce_api_client);
 let uuid = require("uuid");
@@ -64,7 +63,7 @@ const handleReplyAtom = (0, jotai.atom)(null, (get, set, { message, userTyped })
 		attributes: { query: queryTyped }
 	});
 	if (trackEvent) trackEvent({
-		eventName: require_utils.SpiffyMetricsEventName.ChatUserMessageInput,
+		eventName: require_dist.SpiffyMetricsEventName.ChatUserMessageInput,
 		eventProps: {
 			message_id: message.id,
 			message_role: message.role,
@@ -324,4 +323,4 @@ Object.defineProperty(exports, 'widgetArrayAtom', {
     return widgetArrayAtom;
   }
 });
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"chat-BJL3nXR7.cjs","names":["MessageType","amplitudeTrackEventAtom","replyEventCategoryAtom","UserEventCategory","userQueryAtom","messagesAtom","userHasRepliedAtom","SpiffyMetricsEventName","sessionStorageUtil","getAtomStore","replyEventCategoryAtom","UserEventCategory","formSubmitAtom","newMessage: Message","MessageRole","MessageType","replyEventCategoryAtom","UserEventCategory","suggestionAtom","messagesAtom","userHasRepliedAtom","messagesAtom","userHasRepliedAtom","getAtomStore","userHasRepliedAtom","replyEventCategoryAtom","userQueryAtom","suggestionAtom","askQuestionBtnClickedAtom","messagesAtom","userEventsAtom","suggestionsAtom","suggestionsLoadingAtom","responseStreamingAtom","chatIsOpenAtom","chatOnToggleAtom"],"sources":["../src/atoms/chat/messageQueue.ts","../src/atoms/chat/replies.ts","../src/atoms/chat/performanceMetrics.ts","../src/atoms/chat/form.ts","../src/atoms/chat/suggestions.ts","../src/atoms/chat/lastMessage.ts","../src/atoms/chat/renderedWidgetRefs.ts","../src/atoms/chat/index.ts"],"sourcesContent":["import { atom } from 'jotai';\nimport { v4 as uuid } from 'uuid';\nimport { GenerationParams, NextMessageRequest, UserEvent } from '@envive-ai/types';\nimport { getAtomStore } from 'src/atoms/atomStore/atomStore';\nimport { userIdAtom, chatIdAtom } from 'src/atoms/app';\nimport { orgShortNameAtom, contextSourceAtom, envAtom } from 'src/atoms/envive/enviveConfig';\nimport { orgIdAtom, featureFlagServiceAtom } from 'src/atoms/org/graphqlConfig';\n\nconst internalUserEventQueueAtom = atom<UserEvent[]>([]);\n\nexport const userEventQueueAtom = atom((get) => {\n  const queue = get(internalUserEventQueueAtom);\n  return queue === undefined ? [] : queue.filter((v) => v !== undefined);\n});\n\n/**\n * This atom is used to queue a new message for processing on `next_responses`\n * It receives a single `userEvent` that is added to the processing queue.\n * If the event has the same eventId as an existing message in the queue the NEW\n * event is ignored\n */\nexport const queueUserEventAtom = atom(null, (get, set, userEvent: UserEvent) => {\n  if (userEvent === undefined) {\n    return;\n  }\n  set(internalUserEventQueueAtom, [...get(internalUserEventQueueAtom), userEvent]);\n});\n\n/**\n * This atom exposes a function to reset the entire queue. All messages in the queue will be purged\n */\nexport const clearUserEventAtom = atom(null, (_, set) => {\n  set(internalUserEventQueueAtom, []);\n});\n\n/**\n * This atom is used to mark events as processed and remove them from the queue\n * It accepts a list of eventId values and will remove all events with those eventIds from the queue.\n */\nexport const processUserEventAtom = atom(null, (get, set, eventIds: string[]) => {\n  const curr = get(internalUserEventQueueAtom);\n  const remaining = curr?.filter((event) => !eventIds.includes(event.eventId));\n  set(internalUserEventQueueAtom, remaining);\n});\n\nexport const userQueueEventCountAtom = atom((get) => get(userEventQueueAtom).length);\n\nimport { ContextSourceEnum, ContextEnvEnum } from '@spiffy-ai/commerce-api-client'; // Import necessary enums\n// import type { Context } from \"@spiffy-ai/commerce-api-client/dist/models/Context\"; // Import Context type\n\nexport const createResponsePayload = ({\n  userEvents,\n  generationParams,\n}: {\n  userEvents: UserEvent[];\n  generationParams?: GenerationParams;\n}): NextMessageRequest => {\n  const atomStore = getAtomStore();\n  const orgShortName = atomStore.get(orgShortNameAtom);\n  const orgId = atomStore.get(orgIdAtom);\n  const userId = atomStore.get(userIdAtom);\n  const chatId = atomStore.get(chatIdAtom);\n  const source = atomStore.get(contextSourceAtom);\n  const env = atomStore.get(envAtom);\n\n  const featureFlagService = atomStore.get(featureFlagServiceAtom);\n\n  const context = {\n    userId: userId ?? '',\n    org_id: orgId ?? '',\n    org_short_name: orgShortName ?? '',\n    chat_id: chatId ?? '',\n    source: source ?? ContextSourceEnum.App,\n    env: (env as ContextEnvEnum) ?? ContextEnvEnum.Dev,\n  };\n\n  const featureFlags = featureFlagService?.featureFlagService?.getFeatureFlags() || {};\n\n  return {\n    id: uuid(),\n    context,\n    userEvents,\n    featureFlags: Object.fromEntries(\n      Object.entries(featureFlags).filter(([, isEnabled]) => isEnabled),\n    ), // Convert back to Record<string, boolean>\n    generationParams,\n  };\n};\n","import { atom } from 'jotai';\nimport { Message, MessageType } from '@envive-ai/types';\nimport {\n  userHasRepliedAtom,\n  messagesAtom,\n  userQueryAtom,\n  replyEventCategoryAtom,\n} from 'src/atoms/chat';\nimport { UserEventCategory } from '@spiffy-ai/commerce-api-client';\nimport { queueUserEventAtom } from './messageQueue';\nimport { SpiffyMetricsEventName } from 'src/contexts/amplitudeContext/amplitudeContext';\nimport { amplitudeTrackEventAtom } from 'src/atoms/amplitude/amplitudeTrackEventAtom';\n\ntype HandleReplyParams = {\n  message: Message;\n  userTyped: boolean;\n};\n\nexport const handleReplyAtom = atom(null, (get, set, { message, userTyped }: HandleReplyParams) => {\n  if (message.type !== MessageType.QueryTyped) {\n    return;\n  }\n\n  const trackEvent = get(amplitudeTrackEventAtom);\n  const queryTyped = message.metadata.content;\n\n  set(replyEventCategoryAtom, UserEventCategory.QueryTyped);\n  set(userQueryAtom, queryTyped);\n  set(messagesAtom, [...get(messagesAtom), [message]]);\n  set(userHasRepliedAtom, true);\n  set(queueUserEventAtom, {\n    eventId: message.id,\n    createdAt: message.createdAt,\n    category: UserEventCategory.QueryTyped,\n    attributes: {\n      query: queryTyped,\n    },\n  });\n\n  if (trackEvent) {\n    trackEvent({\n      eventName: SpiffyMetricsEventName.ChatUserMessageInput,\n      eventProps: {\n        message_id: message.id,\n        message_role: message.role,\n        message_type: message.type,\n        message_metadata: {\n          content: message?.metadata?.content, // Removed amplitudeSafeString\n          created_at: message.createdAt,\n          user_typed: userTyped,\n        },\n      },\n      alsoSendToGoogleAnalytics: true,\n    });\n  }\n});\n","import { atom } from \"jotai\";\nimport { atomWithStorage } from \"jotai/utils\";\nimport Logger from \"src/application/logging/logger\";\nimport {\n  getAtomStore,\n  sessionStorageUtil,\n} from \"src/atoms/atomStore/atomStore\";\n\nexport const APP_INITIAL_START_TIME_KEY = \"spiffy-app-initial-start-time\";\nexport const PAGE_LOAD_OFFSET_TIME_KEY = \"spiffy-page-load-offset-time\";\n/**\n * The different performance metrics that can be logged. All times are relative to the\n * initial start time of the app and are stored in milliseconds.\n */\nexport enum PerfMetricsEvents {\n  PageLoadOffset = \"page_load_offset_ms\",\n  MainBundleLoaded = \"main_bundle_loaded_ms\",\n  OrgConfigLoadStarted = \"org_config_load_started_ms\",\n  OrgConfigLoadEnded = \"org_config_load_ended_ms\",\n  FirstResponseStarted = \"first_response_started_ms\",\n  FirstResponseCompleted = \"first_response_completed_ms\",\n  FirstSuggestionsStarted = \"first_suggestions_started_ms\",\n  FirstSuggestionsCompleted = \"first_suggestions_completed_ms\",\n  EmbeddedWidgetRendered = \"embedded_widget_rendered_ms\",\n  FloatingButtonRendered = \"floating_button_rendered_ms\",\n  TopSuggestionsBarRendered = \"top_suggestions_bar_rendered_ms\",\n  BottomSuggestionsBarRendered = \"bottom_suggestions_bar_rendered_ms\",\n  SearchPromptRendered = \"search_prompt_rendered_ms\",\n}\n\nconst internalPerfMetricsAtom = atom<Map<PerfMetricsEvents, number>>(new Map());\nexport const appInitialStartTimeMsAtom = atomWithStorage<string | undefined>(\n  APP_INITIAL_START_TIME_KEY,\n  sessionStorage.getItem(APP_INITIAL_START_TIME_KEY) ?? undefined,\n  sessionStorageUtil,\n  {\n    getOnInit: true,\n  }\n);\n\nexport const pageLoadOffsetTimeAtom = atomWithStorage<string | undefined>(\n  PAGE_LOAD_OFFSET_TIME_KEY,\n  sessionStorage.getItem(PAGE_LOAD_OFFSET_TIME_KEY) ?? undefined,\n  sessionStorageUtil,\n  {\n    getOnInit: true,\n  }\n);\n\n/**\n * Resets the performance metrics atom to an empty map. This should be called after the performance\n * metrics have been reported to amplitude. On SPA, it ensures that we can still capture metrics as\n * the user navigates around the app (although there is more work to be done to fully enable this).\n * On non-SPA, it ensures that previously captured metrics are not reported again.\n */\nexport const resetPerformanceMetricsAtom = () => {\n  const atomStore = getAtomStore();\n  atomStore.set(internalPerfMetricsAtom, new Map());\n};\nexport const performanceMetricsAtom = atom((get) =>\n  get(internalPerfMetricsAtom)\n);\nexport const hasReportedPerformanceMetricsAtom = atom<boolean>(false);\n\n/**\n * Logs a performance metric by capturing the delta between the initial app start time\n * and the current time. If the metric has already been logged, it will not be logged again.\n *\n * @param value The performance metric name to log.\n */\nexport const logPerfMetricAtom = atom(\n  null,\n  (get, set, value: PerfMetricsEvents) => {\n    const initialTimeStorageValue = get(appInitialStartTimeMsAtom);\n    const initialTimeMs = initialTimeStorageValue\n      ? parseInt(initialTimeStorageValue, 10)\n      : undefined;\n\n    if (initialTimeMs == null) {\n      Logger.logWarn(\n        `[spiffy-ai] No initial app start time found. Skipping...`,\n        undefined\n      );\n      return;\n    }\n\n    const currentPerfMetrics = get(internalPerfMetricsAtom);\n    if (currentPerfMetrics.has(value)) {\n      return;\n    }\n\n    const currentTimeMs = Date.now();\n    const deltaMs = currentTimeMs - initialTimeMs;\n    currentPerfMetrics.set(value, deltaMs);\n    set(internalPerfMetricsAtom, currentPerfMetrics);\n  }\n);\n","import { UserEventCategory } from '@spiffy-ai/commerce-api-client';\nimport { atom } from 'jotai';\nimport { FormSubmittedAttributes, UserEvent } from '@envive-ai/types';\nimport { v4 as uuid } from 'uuid';\nimport { formSubmitAtom, replyEventCategoryAtom } from 'src/atoms/chat';\nimport { queueUserEventAtom } from 'src/atoms/chat/messageQueue';\n\nexport const handleFormSubmittedAtom = atom(null, (_, set, form: FormSubmittedAttributes) => {\n  set(replyEventCategoryAtom, UserEventCategory.FormSubmitted);\n  set(formSubmitAtom, form);\n\n  const formUserEvent = {\n    eventId: uuid(),\n    category: UserEventCategory.FormSubmitted,\n    createdAt: new Date().toISOString(),\n    attributes: form,\n  } satisfies UserEvent;\n  set(queueUserEventAtom, formUserEvent);\n});\n","import { atom } from \"jotai\";\nimport { Message, MessageRole, MessageType, Suggestion } from \"src/types\";\nimport {\n  messagesAtom,\n  replyEventCategoryAtom,\n  suggestionAtom,\n  userHasRepliedAtom,\n} from \"src/atoms/chat\";\nimport { FilterAttribute, ProductResponseAttributes } from \"src/types\";\n\nimport { UserEventCategory } from \"@spiffy-ai/commerce-api-client\";\nimport { queueUserEventAtom } from \"./messageQueue\";\n\nexport const handleSuggestionAtom = atom(\n  null,\n  (get, set, suggestion: Suggestion) => {\n    const newMessage: Message = {\n      id: suggestion.id,\n      role: MessageRole.User,\n      type: MessageType.SuggestionClicked,\n      createdAt: new Date().toISOString(),\n      metadata: {\n        suggestionId: suggestion.id,\n        suggestionContent: suggestion.content,\n      },\n    };\n\n    set(replyEventCategoryAtom, UserEventCategory.SuggestionClicked);\n    set(suggestionAtom, suggestion);\n    set(messagesAtom, [...get(messagesAtom), [newMessage]]);\n    set(userHasRepliedAtom, true);\n    set(queueUserEventAtom, {\n      eventId: suggestion.id,\n      category: UserEventCategory.SuggestionClicked,\n      createdAt: newMessage.createdAt,\n      attributes: {\n        suggestionId: suggestion.id,\n      },\n    });\n  }\n);\n","import { atom } from 'jotai';\nimport { messagesAtom, userHasRepliedAtom } from 'src/atoms/chat';\n\nexport const lastAssistantMessageAtom = atom((get) => {\n  const messages = get(messagesAtom);\n  const userHasReplied = get(userHasRepliedAtom);\n  if (messages.length > 0 && !userHasReplied) {\n    return messages[messages.length - 1];\n  }\n  return null;\n});\n","import { atom } from \"jotai\";\nimport { getAtomStore } from \"src/atoms/atomStore/atomStore\";\n\nconst internalWidgetArrayAtom = atom<HTMLElement[]>([]);\n\nexport const widgetArrayAtom = atom((get) => get(internalWidgetArrayAtom));\n\n/**\n * This function call is used to create a list of the Spiffy widgets\n * that are rendering on the page.\n *\n * It is used by the FloatingButton widget to slide out of view when it\n * overlaps with another Spiffy widget.\n *\n * The spiffy widgets should be added to the this array for the floating button\n * to know about them.\n *\n * Today the \"SuggestionBar\" widget is not added, but the other widgets are.\n *\n */\nexport const addWidget = (ref: HTMLElement, idx?: number) => {\n  const atomStore = getAtomStore();\n  const val = atomStore.get(internalWidgetArrayAtom);\n  const insertIdx = idx ?? val.length;\n  val[insertIdx] = ref;\n  atomStore.set(internalWidgetArrayAtom, val);\n};\n","import { atom } from 'jotai';\nimport {\n  responseStreamingAtom,\n  suggestionsLoadingAtom,\n  messagesAtom,\n  userQueryAtom,\n  replyEventCategoryAtom,\n  userHasRepliedAtom,\n  askQuestionBtnClickedAtom,\n  suggestionsAtom,\n  chatIsOpenAtom,\n  chatOnToggleAtom,\n  userEventsAtom,\n  suggestionAtom,\n} from './chatState';\n\nexport * from './chatState';\nexport * from './replies';\nexport * from './performanceMetrics';\nexport * from './form';\nexport * from './suggestions';\nexport * from './lastMessage';\nexport * from './renderedWidgetRefs';\n\nexport const chatAtom = atom((get) => ({\n  userHasReplied: get(userHasRepliedAtom),\n  replyEventCategory: get(replyEventCategoryAtom),\n  userQuery: get(userQueryAtom),\n  suggestion: get(suggestionAtom),\n  askQuestionBtnClicked: get(askQuestionBtnClickedAtom),\n  messages: get(messagesAtom),\n  userEvents: get(userEventsAtom),\n  suggestions: get(suggestionsAtom),\n  suggestionsLoading: get(suggestionsLoadingAtom),\n  responseStreaming: get(responseStreamingAtom),\n  isOpen: get(chatIsOpenAtom),\n  onToggle: get(chatOnToggleAtom),\n}));\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"chat-CCjM6fS_.cjs","names":["MessageType","amplitudeTrackEventAtom","replyEventCategoryAtom","UserEventCategory","userQueryAtom","messagesAtom","userHasRepliedAtom","SpiffyMetricsEventName","sessionStorageUtil","getAtomStore","replyEventCategoryAtom","UserEventCategory","formSubmitAtom","newMessage: Message","MessageRole","MessageType","replyEventCategoryAtom","UserEventCategory","suggestionAtom","messagesAtom","userHasRepliedAtom","messagesAtom","userHasRepliedAtom","getAtomStore","userHasRepliedAtom","replyEventCategoryAtom","userQueryAtom","suggestionAtom","askQuestionBtnClickedAtom","messagesAtom","userEventsAtom","suggestionsAtom","suggestionsLoadingAtom","responseStreamingAtom","chatIsOpenAtom","chatOnToggleAtom"],"sources":["../src/atoms/chat/messageQueue.ts","../src/atoms/chat/replies.ts","../src/atoms/chat/performanceMetrics.ts","../src/atoms/chat/form.ts","../src/atoms/chat/suggestions.ts","../src/atoms/chat/lastMessage.ts","../src/atoms/chat/renderedWidgetRefs.ts","../src/atoms/chat/index.ts"],"sourcesContent":["import { atom } from 'jotai';\nimport { v4 as uuid } from 'uuid';\nimport { GenerationParams, NextMessageRequest, UserEvent } from '@envive-ai/types';\nimport { getAtomStore } from 'src/atoms/atomStore/atomStore';\nimport { userIdAtom, chatIdAtom } from 'src/atoms/app';\nimport { orgShortNameAtom, contextSourceAtom, envAtom } from 'src/atoms/envive/enviveConfig';\nimport { orgIdAtom, featureFlagServiceAtom } from 'src/atoms/org/graphqlConfig';\n\nconst internalUserEventQueueAtom = atom<UserEvent[]>([]);\n\nexport const userEventQueueAtom = atom((get) => {\n  const queue = get(internalUserEventQueueAtom);\n  return queue === undefined ? [] : queue.filter((v) => v !== undefined);\n});\n\n/**\n * This atom is used to queue a new message for processing on `next_responses`\n * It receives a single `userEvent` that is added to the processing queue.\n * If the event has the same eventId as an existing message in the queue the NEW\n * event is ignored\n */\nexport const queueUserEventAtom = atom(null, (get, set, userEvent: UserEvent) => {\n  if (userEvent === undefined) {\n    return;\n  }\n  set(internalUserEventQueueAtom, [...get(internalUserEventQueueAtom), userEvent]);\n});\n\n/**\n * This atom exposes a function to reset the entire queue. All messages in the queue will be purged\n */\nexport const clearUserEventAtom = atom(null, (_, set) => {\n  set(internalUserEventQueueAtom, []);\n});\n\n/**\n * This atom is used to mark events as processed and remove them from the queue\n * It accepts a list of eventId values and will remove all events with those eventIds from the queue.\n */\nexport const processUserEventAtom = atom(null, (get, set, eventIds: string[]) => {\n  const curr = get(internalUserEventQueueAtom);\n  const remaining = curr?.filter((event) => !eventIds.includes(event.eventId));\n  set(internalUserEventQueueAtom, remaining);\n});\n\nexport const userQueueEventCountAtom = atom((get) => get(userEventQueueAtom).length);\n\nimport { ContextSourceEnum, ContextEnvEnum } from '@spiffy-ai/commerce-api-client'; // Import necessary enums\n// import type { Context } from \"@spiffy-ai/commerce-api-client/dist/models/Context\"; // Import Context type\n\nexport const createResponsePayload = ({\n  userEvents,\n  generationParams,\n}: {\n  userEvents: UserEvent[];\n  generationParams?: GenerationParams;\n}): NextMessageRequest => {\n  const atomStore = getAtomStore();\n  const orgShortName = atomStore.get(orgShortNameAtom);\n  const orgId = atomStore.get(orgIdAtom);\n  const userId = atomStore.get(userIdAtom);\n  const chatId = atomStore.get(chatIdAtom);\n  const source = atomStore.get(contextSourceAtom);\n  const env = atomStore.get(envAtom);\n\n  const featureFlagService = atomStore.get(featureFlagServiceAtom);\n\n  const context = {\n    userId: userId ?? '',\n    org_id: orgId ?? '',\n    org_short_name: orgShortName ?? '',\n    chat_id: chatId ?? '',\n    source: source ?? ContextSourceEnum.App,\n    env: (env as ContextEnvEnum) ?? ContextEnvEnum.Dev,\n  };\n\n  const featureFlags = featureFlagService?.featureFlagService?.getFeatureFlags() || {};\n\n  return {\n    id: uuid(),\n    context,\n    userEvents,\n    featureFlags: Object.fromEntries(\n      Object.entries(featureFlags).filter(([, isEnabled]) => isEnabled),\n    ), // Convert back to Record<string, boolean>\n    generationParams,\n  };\n};\n","import { atom } from \"jotai\";\nimport { Message, MessageType, SpiffyMetricsEventName } from \"@envive-ai/types\";\nimport {\n  userHasRepliedAtom,\n  messagesAtom,\n  userQueryAtom,\n  replyEventCategoryAtom,\n} from \"src/atoms/chat\";\nimport { UserEventCategory } from \"@spiffy-ai/commerce-api-client\";\nimport { queueUserEventAtom } from \"./messageQueue\";\nimport { amplitudeTrackEventAtom } from \"src/atoms/amplitude/amplitudeTrackEventAtom\";\n\ntype HandleReplyParams = {\n  message: Message;\n  userTyped: boolean;\n};\n\nexport const handleReplyAtom = atom(\n  null,\n  (get, set, { message, userTyped }: HandleReplyParams) => {\n    if (message.type !== MessageType.QueryTyped) {\n      return;\n    }\n\n    const trackEvent = get(amplitudeTrackEventAtom);\n    const queryTyped = message.metadata.content;\n\n    set(replyEventCategoryAtom, UserEventCategory.QueryTyped);\n    set(userQueryAtom, queryTyped);\n    set(messagesAtom, [...get(messagesAtom), [message]]);\n    set(userHasRepliedAtom, true);\n    set(queueUserEventAtom, {\n      eventId: message.id,\n      createdAt: message.createdAt,\n      category: UserEventCategory.QueryTyped,\n      attributes: {\n        query: queryTyped,\n      },\n    });\n\n    if (trackEvent) {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.ChatUserMessageInput,\n        eventProps: {\n          message_id: message.id,\n          message_role: message.role,\n          message_type: message.type,\n          message_metadata: {\n            content: message?.metadata?.content, // Removed amplitudeSafeString\n            created_at: message.createdAt,\n            user_typed: userTyped,\n          },\n        },\n        alsoSendToGoogleAnalytics: true,\n      });\n    }\n  }\n);\n","import { atom } from \"jotai\";\nimport { atomWithStorage } from \"jotai/utils\";\nimport Logger from \"src/application/logging/logger\";\nimport {\n  getAtomStore,\n  sessionStorageUtil,\n} from \"src/atoms/atomStore/atomStore\";\n\nexport const APP_INITIAL_START_TIME_KEY = \"spiffy-app-initial-start-time\";\nexport const PAGE_LOAD_OFFSET_TIME_KEY = \"spiffy-page-load-offset-time\";\n/**\n * The different performance metrics that can be logged. All times are relative to the\n * initial start time of the app and are stored in milliseconds.\n */\nexport enum PerfMetricsEvents {\n  PageLoadOffset = \"page_load_offset_ms\",\n  MainBundleLoaded = \"main_bundle_loaded_ms\",\n  OrgConfigLoadStarted = \"org_config_load_started_ms\",\n  OrgConfigLoadEnded = \"org_config_load_ended_ms\",\n  FirstResponseStarted = \"first_response_started_ms\",\n  FirstResponseCompleted = \"first_response_completed_ms\",\n  FirstSuggestionsStarted = \"first_suggestions_started_ms\",\n  FirstSuggestionsCompleted = \"first_suggestions_completed_ms\",\n  EmbeddedWidgetRendered = \"embedded_widget_rendered_ms\",\n  FloatingButtonRendered = \"floating_button_rendered_ms\",\n  TopSuggestionsBarRendered = \"top_suggestions_bar_rendered_ms\",\n  BottomSuggestionsBarRendered = \"bottom_suggestions_bar_rendered_ms\",\n  SearchPromptRendered = \"search_prompt_rendered_ms\",\n}\n\nconst internalPerfMetricsAtom = atom<Map<PerfMetricsEvents, number>>(new Map());\nexport const appInitialStartTimeMsAtom = atomWithStorage<string | undefined>(\n  APP_INITIAL_START_TIME_KEY,\n  sessionStorage.getItem(APP_INITIAL_START_TIME_KEY) ?? undefined,\n  sessionStorageUtil,\n  {\n    getOnInit: true,\n  }\n);\n\nexport const pageLoadOffsetTimeAtom = atomWithStorage<string | undefined>(\n  PAGE_LOAD_OFFSET_TIME_KEY,\n  sessionStorage.getItem(PAGE_LOAD_OFFSET_TIME_KEY) ?? undefined,\n  sessionStorageUtil,\n  {\n    getOnInit: true,\n  }\n);\n\n/**\n * Resets the performance metrics atom to an empty map. This should be called after the performance\n * metrics have been reported to amplitude. On SPA, it ensures that we can still capture metrics as\n * the user navigates around the app (although there is more work to be done to fully enable this).\n * On non-SPA, it ensures that previously captured metrics are not reported again.\n */\nexport const resetPerformanceMetricsAtom = () => {\n  const atomStore = getAtomStore();\n  atomStore.set(internalPerfMetricsAtom, new Map());\n};\nexport const performanceMetricsAtom = atom((get) =>\n  get(internalPerfMetricsAtom)\n);\nexport const hasReportedPerformanceMetricsAtom = atom<boolean>(false);\n\n/**\n * Logs a performance metric by capturing the delta between the initial app start time\n * and the current time. If the metric has already been logged, it will not be logged again.\n *\n * @param value The performance metric name to log.\n */\nexport const logPerfMetricAtom = atom(\n  null,\n  (get, set, value: PerfMetricsEvents) => {\n    const initialTimeStorageValue = get(appInitialStartTimeMsAtom);\n    const initialTimeMs = initialTimeStorageValue\n      ? parseInt(initialTimeStorageValue, 10)\n      : undefined;\n\n    if (initialTimeMs == null) {\n      Logger.logWarn(\n        `[spiffy-ai] No initial app start time found. Skipping...`,\n        undefined\n      );\n      return;\n    }\n\n    const currentPerfMetrics = get(internalPerfMetricsAtom);\n    if (currentPerfMetrics.has(value)) {\n      return;\n    }\n\n    const currentTimeMs = Date.now();\n    const deltaMs = currentTimeMs - initialTimeMs;\n    currentPerfMetrics.set(value, deltaMs);\n    set(internalPerfMetricsAtom, currentPerfMetrics);\n  }\n);\n","import { UserEventCategory } from '@spiffy-ai/commerce-api-client';\nimport { atom } from 'jotai';\nimport { FormSubmittedAttributes, UserEvent } from '@envive-ai/types';\nimport { v4 as uuid } from 'uuid';\nimport { formSubmitAtom, replyEventCategoryAtom } from 'src/atoms/chat';\nimport { queueUserEventAtom } from 'src/atoms/chat/messageQueue';\n\nexport const handleFormSubmittedAtom = atom(null, (_, set, form: FormSubmittedAttributes) => {\n  set(replyEventCategoryAtom, UserEventCategory.FormSubmitted);\n  set(formSubmitAtom, form);\n\n  const formUserEvent = {\n    eventId: uuid(),\n    category: UserEventCategory.FormSubmitted,\n    createdAt: new Date().toISOString(),\n    attributes: form,\n  } satisfies UserEvent;\n  set(queueUserEventAtom, formUserEvent);\n});\n","import { atom } from \"jotai\";\nimport { Message, MessageRole, MessageType, Suggestion } from \"src/types\";\nimport {\n  messagesAtom,\n  replyEventCategoryAtom,\n  suggestionAtom,\n  userHasRepliedAtom,\n} from \"src/atoms/chat\";\nimport { FilterAttribute, ProductResponseAttributes } from \"src/types\";\n\nimport { UserEventCategory } from \"@spiffy-ai/commerce-api-client\";\nimport { queueUserEventAtom } from \"./messageQueue\";\n\nexport const handleSuggestionAtom = atom(\n  null,\n  (get, set, suggestion: Suggestion) => {\n    const newMessage: Message = {\n      id: suggestion.id,\n      role: MessageRole.User,\n      type: MessageType.SuggestionClicked,\n      createdAt: new Date().toISOString(),\n      metadata: {\n        suggestionId: suggestion.id,\n        suggestionContent: suggestion.content,\n      },\n    };\n\n    set(replyEventCategoryAtom, UserEventCategory.SuggestionClicked);\n    set(suggestionAtom, suggestion);\n    set(messagesAtom, [...get(messagesAtom), [newMessage]]);\n    set(userHasRepliedAtom, true);\n    set(queueUserEventAtom, {\n      eventId: suggestion.id,\n      category: UserEventCategory.SuggestionClicked,\n      createdAt: newMessage.createdAt,\n      attributes: {\n        suggestionId: suggestion.id,\n      },\n    });\n  }\n);\n","import { atom } from 'jotai';\nimport { messagesAtom, userHasRepliedAtom } from 'src/atoms/chat';\n\nexport const lastAssistantMessageAtom = atom((get) => {\n  const messages = get(messagesAtom);\n  const userHasReplied = get(userHasRepliedAtom);\n  if (messages.length > 0 && !userHasReplied) {\n    return messages[messages.length - 1];\n  }\n  return null;\n});\n","import { atom } from \"jotai\";\nimport { getAtomStore } from \"src/atoms/atomStore/atomStore\";\n\nconst internalWidgetArrayAtom = atom<HTMLElement[]>([]);\n\nexport const widgetArrayAtom = atom((get) => get(internalWidgetArrayAtom));\n\n/**\n * This function call is used to create a list of the Spiffy widgets\n * that are rendering on the page.\n *\n * It is used by the FloatingButton widget to slide out of view when it\n * overlaps with another Spiffy widget.\n *\n * The spiffy widgets should be added to the this array for the floating button\n * to know about them.\n *\n * Today the \"SuggestionBar\" widget is not added, but the other widgets are.\n *\n */\nexport const addWidget = (ref: HTMLElement, idx?: number) => {\n  const atomStore = getAtomStore();\n  const val = atomStore.get(internalWidgetArrayAtom);\n  const insertIdx = idx ?? val.length;\n  val[insertIdx] = ref;\n  atomStore.set(internalWidgetArrayAtom, val);\n};\n","import { atom } from 'jotai';\nimport {\n  responseStreamingAtom,\n  suggestionsLoadingAtom,\n  messagesAtom,\n  userQueryAtom,\n  replyEventCategoryAtom,\n  userHasRepliedAtom,\n  askQuestionBtnClickedAtom,\n  suggestionsAtom,\n  chatIsOpenAtom,\n  chatOnToggleAtom,\n  userEventsAtom,\n  suggestionAtom,\n} from './chatState';\n\nexport * from './chatState';\nexport * from './replies';\nexport * from './performanceMetrics';\nexport * from './form';\nexport * from './suggestions';\nexport * from './lastMessage';\nexport * from './renderedWidgetRefs';\n\nexport const chatAtom = atom((get) => ({\n  userHasReplied: get(userHasRepliedAtom),\n  replyEventCategory: get(replyEventCategoryAtom),\n  userQuery: get(userQueryAtom),\n  suggestion: get(suggestionAtom),\n  askQuestionBtnClicked: get(askQuestionBtnClickedAtom),\n  messages: get(messagesAtom),\n  userEvents: get(userEventsAtom),\n  suggestions: get(suggestionsAtom),\n  suggestionsLoading: get(suggestionsLoadingAtom),\n  responseStreaming: get(responseStreamingAtom),\n  isOpen: get(chatIsOpenAtom),\n  onToggle: get(chatOnToggleAtom),\n}));\n"],"mappings":"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"}

package/dist/{chat-DCGriB7h.cjs → chat-CJ9D8n7g.cjs}

@@ -142,4 +142,4 @@ Object.defineProperty(exports, 'TAG_TESTID', {
     return TAG_TESTID;
   }
 });
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/{chat-ClvJ9xEj.js → chat-EJbfGWRr.js}

@@ -22,4 +22,4 @@ const ANIMATED_MESSAGES_TESTID = "spiffy-animated-messages";
 
 //#endregion
 export { ANIMATED_MESSAGES_TESTID, CHAT_CONTAINER_ID, CHAT_HEADER_CLOSE_BUTTON_TESTID, CHAT_HEADER_CONTAINER_TESTID, CHAT_MESSAGE_CONTAINER_TESTID, CHAT_MESSAGE_DIVIDER_TESTID, CHAT_MODAL_TESTID, CHAT_REPLY_INPUT_SEND_BUTTON_TESTID, CHAT_REPLY_INPUT_TESTID, CHAT_VIEW_PREVIOUS_MESSAGES_TESTID, DYNAMIC_CAROUSEL_TESTID, IMAGE_STACK_FIRST_IMAGE_TESTID, IMAGE_STACK_SECOND_IMAGE_TESTID, IMAGE_STACK_TESTID, LOADING_MESSAGE_CONTAINER_TESTID, MOBILE_CHAT_HEADER_TESTID, SCROLLABLE_SUGGESTIONS_TESTID, SUGGESTION_BAR_BUTTON_TESTID, SUGGESTION_BAR_TESTID, TAG_TESTID };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/chatState-BbI93m6r.js

@@ -0,0 +1,33 @@
+import { SpiffyEventName, SpiffyMetricsEventName } from "./dist-C38adNK1.js";
+import { atom } from "jotai";
+import { UserEventCategory } from "@spiffy-ai/commerce-api-client/dist/models/UserEventCategory";
+
+//#region src/atoms/chat/chatState.ts
+const userHasRepliedAtom = atom(false);
+const replyEventCategoryAtom = atom(UserEventCategory.AppLoaded);
+const userQueryAtom = atom();
+const suggestionAtom = atom(void 0);
+const askQuestionBtnClickedAtom = atom(false);
+const messagesAtom = atom([]);
+const userEventsAtom = atom([]);
+const suggestionsAtom = atom([]);
+const suggestionsLoadingAtom = atom(false);
+const responseStreamingAtom = atom(false);
+const chatIsOpenAtom = atom(false);
+const requestFailureAtom = atom(false);
+const formSubmitAtom = atom();
+const chatOnToggleAtom = atom(null, (get, set, triggerLocation, track) => {
+	const isOpen = get(chatIsOpenAtom);
+	set(chatIsOpenAtom, !isOpen);
+	if (!isOpen) {
+		window.dispatchEvent(new CustomEvent(SpiffyEventName.WidgetOpen));
+		track?.(SpiffyMetricsEventName.ChatComponentExpanded, { message_metadata: { trigger_location: triggerLocation } });
+	} else {
+		window.dispatchEvent(new CustomEvent(SpiffyEventName.WidgetClose));
+		track?.(SpiffyMetricsEventName.ChatComponentCollapsed);
+	}
+});
+
+//#endregion
+export { askQuestionBtnClickedAtom, chatIsOpenAtom, chatOnToggleAtom, formSubmitAtom, messagesAtom, replyEventCategoryAtom, requestFailureAtom, responseStreamingAtom, suggestionAtom, suggestionsAtom, suggestionsLoadingAtom, userEventsAtom, userHasRepliedAtom, userQueryAtom };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/chatState-DlJpHAsW.cjs

@@ -0,0 +1,119 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_dist = require('./dist-VxRI6eQv.cjs');
+let jotai = require("jotai");
+jotai = require_chunk.__toESM(jotai);
+let __spiffy_ai_commerce_api_client_dist_models_UserEventCategory = require("@spiffy-ai/commerce-api-client/dist/models/UserEventCategory");
+__spiffy_ai_commerce_api_client_dist_models_UserEventCategory = require_chunk.__toESM(__spiffy_ai_commerce_api_client_dist_models_UserEventCategory);
+
+//#region src/atoms/chat/chatState.ts
+const userHasRepliedAtom = (0, jotai.atom)(false);
+const replyEventCategoryAtom = (0, jotai.atom)(__spiffy_ai_commerce_api_client_dist_models_UserEventCategory.UserEventCategory.AppLoaded);
+const userQueryAtom = (0, jotai.atom)();
+const suggestionAtom = (0, jotai.atom)(void 0);
+const askQuestionBtnClickedAtom = (0, jotai.atom)(false);
+const messagesAtom = (0, jotai.atom)([]);
+const userEventsAtom = (0, jotai.atom)([]);
+const suggestionsAtom = (0, jotai.atom)([]);
+const suggestionsLoadingAtom = (0, jotai.atom)(false);
+const responseStreamingAtom = (0, jotai.atom)(false);
+const chatIsOpenAtom = (0, jotai.atom)(false);
+const requestFailureAtom = (0, jotai.atom)(false);
+const formSubmitAtom = (0, jotai.atom)();
+const chatOnToggleAtom = (0, jotai.atom)(null, (get, set, triggerLocation, track) => {
+	const isOpen = get(chatIsOpenAtom);
+	set(chatIsOpenAtom, !isOpen);
+	if (!isOpen) {
+		window.dispatchEvent(new CustomEvent(require_dist.SpiffyEventName.WidgetOpen));
+		track?.(require_dist.SpiffyMetricsEventName.ChatComponentExpanded, { message_metadata: { trigger_location: triggerLocation } });
+	} else {
+		window.dispatchEvent(new CustomEvent(require_dist.SpiffyEventName.WidgetClose));
+		track?.(require_dist.SpiffyMetricsEventName.ChatComponentCollapsed);
+	}
+});
+
+//#endregion
+Object.defineProperty(exports, 'askQuestionBtnClickedAtom', {
+  enumerable: true,
+  get: function () {
+    return askQuestionBtnClickedAtom;
+  }
+});
+Object.defineProperty(exports, 'chatIsOpenAtom', {
+  enumerable: true,
+  get: function () {
+    return chatIsOpenAtom;
+  }
+});
+Object.defineProperty(exports, 'chatOnToggleAtom', {
+  enumerable: true,
+  get: function () {
+    return chatOnToggleAtom;
+  }
+});
+Object.defineProperty(exports, 'formSubmitAtom', {
+  enumerable: true,
+  get: function () {
+    return formSubmitAtom;
+  }
+});
+Object.defineProperty(exports, 'messagesAtom', {
+  enumerable: true,
+  get: function () {
+    return messagesAtom;
+  }
+});
+Object.defineProperty(exports, 'replyEventCategoryAtom', {
+  enumerable: true,
+  get: function () {
+    return replyEventCategoryAtom;
+  }
+});
+Object.defineProperty(exports, 'requestFailureAtom', {
+  enumerable: true,
+  get: function () {
+    return requestFailureAtom;
+  }
+});
+Object.defineProperty(exports, 'responseStreamingAtom', {
+  enumerable: true,
+  get: function () {
+    return responseStreamingAtom;
+  }
+});
+Object.defineProperty(exports, 'suggestionAtom', {
+  enumerable: true,
+  get: function () {
+    return suggestionAtom;
+  }
+});
+Object.defineProperty(exports, 'suggestionsAtom', {
+  enumerable: true,
+  get: function () {
+    return suggestionsAtom;
+  }
+});
+Object.defineProperty(exports, 'suggestionsLoadingAtom', {
+  enumerable: true,
+  get: function () {
+    return suggestionsLoadingAtom;
+  }
+});
+Object.defineProperty(exports, 'userEventsAtom', {
+  enumerable: true,
+  get: function () {
+    return userEventsAtom;
+  }
+});
+Object.defineProperty(exports, 'userHasRepliedAtom', {
+  enumerable: true,
+  get: function () {
+    return userHasRepliedAtom;
+  }
+});
+Object.defineProperty(exports, 'userQueryAtom', {
+  enumerable: true,
+  get: function () {
+    return userQueryAtom;
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/{common-DQPvV_S_.cjs → common-CuwWqIJ1.cjs}

@@ -186,4 +186,4 @@ Object.defineProperty(exports, 'USER_QUERY_BUTTON_TESTID', {
     return USER_QUERY_BUTTON_TESTID;
   }
 });
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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