@envive-ai/react-hooks 0.3.32 → 0.3.33

package/dist/services/hardcopyService/hardcopyService.cjs

@@ -0,0 +1,232 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_logger = require('../../application/logging/logger.cjs');
+const require_urlsParser = require('../../application/utils/urlsParser.cjs');
+const require_snakeToCamelTransformer = require('../../application/models/utils/snakeToCamelTransformer.cjs');
+const require_contexts_typesV3 = require('../../contexts/typesV3.cjs');
+const require_eventNames = require('../amplitudeService/eventNames.cjs');
+require('../../application/utils/index.cjs');
+const require_application_commerce_api = require('../../application/commerce-api.cjs');
+require('../amplitudeService/index.cjs');
+let uuid = require("uuid");
+
+//#region src/services/hardcopyService/hardcopyService.ts
+const logger = new require_logger.default("hardcopyService");
+const MOCK_HARDCOPY_RESPONSE = {
+	[require_contexts_typesV3.WidgetTypeV3.PromptCarouselV3]: {
+		responseId: (0, uuid.v4)(),
+		language: "en",
+		values: { promptButtonTexts: [
+			"What are your best sellers?",
+			"Show me summer dresses",
+			"Do you have free shipping?",
+			"What sizes are available?",
+			"Can I return items?"
+		] }
+	},
+	[require_contexts_typesV3.WidgetTypeV3.TitledPromptCarouselV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			titleLabel: "Need some help?",
+			promptButtonTexts: [
+				"What are your best sellers?",
+				"Show me summer dresses",
+				"Do you have free shipping?",
+				"What sizes are available?",
+				"Can I return items?"
+			]
+		}
+	},
+	[require_contexts_typesV3.WidgetTypeV3.SocialProofV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			titleLabel: "Shopping Assistant",
+			numberOfCustomersText: "123 customers",
+			customerQueryText: "found what they were looking for...",
+			primaryButtonText: "Start shopping",
+			secondaryButtonTitleText: "Popular searches",
+			secondaryButtonTexts: [
+				"Why should I buy from you?",
+				"How do I return an item?",
+				"New arrivals",
+				"Sale items",
+				"Popular items"
+			],
+			textFieldPlaceholderText: "Ask me anything..."
+		}
+	},
+	[require_contexts_typesV3.WidgetTypeV3.TypingAnimationV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			titleLabel: "Shopping Assistant",
+			headlineText: "Need help finding",
+			animatedTextSequence: [
+				"the perfect gift for your loved ones?",
+				"something special for the holidays?",
+				"the ideal present for someone special?"
+			],
+			hintText: "Ask me anything",
+			promptButtonTexts: [
+				"What are your best sellers?",
+				"Show me summer dresses",
+				"Do you have free shipping?",
+				"What sizes are available?"
+			],
+			textFieldAriaLabel: "Ask me anything"
+		}
+	},
+	[require_contexts_typesV3.WidgetTypeV3.ChatPreviewComparisonV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			titleLabel: "Shopping Assistant",
+			headlineText: "Need help comparing?",
+			textFieldPlaceholderText: "Ask me anything..."
+		}
+	},
+	[require_contexts_typesV3.WidgetTypeV3.ChatPreviewLoadingV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			titleLabel: "Shopping Assistant",
+			textFieldPlaceholderText: "Ask me anything..."
+		}
+	},
+	[require_contexts_typesV3.WidgetTypeV3.ChatPreviewV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			titleLabel: "Shopping Assistant",
+			textFieldPlaceholderText: "Ask me anything..."
+		}
+	},
+	[require_contexts_typesV3.WidgetTypeV3.PromptButtonCarouselWithImageV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			titleLabel: "Need some help?",
+			promptButtonsTexts: [
+				"Help me find a product",
+				"What's on your mind?",
+				"Talk to a human"
+			],
+			textFieldPlaceholderText: "Ask me anything..."
+		}
+	},
+	[require_contexts_typesV3.WidgetTypeV3.ProductCardV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			headline: "Discover Your Perfect Style",
+			animatedText: [
+				"the perfect outfit for any occasion",
+				"trending fashion that fits your lifestyle",
+				"quality pieces that last"
+			],
+			prompts: [
+				"What are your best sellers?",
+				"Show me summer dresses",
+				"Do you have free shipping?",
+				"What sizes are available?",
+				"Can I return items?"
+			],
+			placeholder: "Ask me anything..."
+		}
+	},
+	[require_contexts_typesV3.WidgetTypeV3.FloatingChatV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			welcomeMessageTitle: "Welcome to Envive AI",
+			welcomeMessageText: "Your personal shopper trained on the collective knowledge of thousands of real experts!",
+			chatFooterTextFieldPlaceholderText: "Ask me anything...",
+			disclaimerText: "This is a disclaimer...",
+			leftToggleLabel: "Shop with AI",
+			rightToggleLabel: "Live support"
+		}
+	},
+	[require_contexts_typesV3.WidgetTypeV3.FullPageSalesAgentV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			welcomeMessageTitle: "Welcome to Envive AI",
+			welcomeMessageText: "Your personal shopper trained on the collective knowledge of thousands of real experts!",
+			chatFooterTextFieldPlaceholderText: "Ask me anything...",
+			disclaimerText: "This is a disclaimer..."
+		}
+	}
+};
+const convertToHardcopyResponse = (response) => ({
+	responseId: response.responseId,
+	language: response.language,
+	rawValues: response.values,
+	values: Object.fromEntries(Object.entries(response.values).map(([key, value]) => [require_snakeToCamelTransformer.toCamelCase(key), value.length === 1 ? value[0].value : value.map((v) => v.value)]))
+});
+var HardcopyService = class {
+	constructor(config) {
+		this.config = config;
+	}
+	async getHardcopy(request) {
+		const overrideConfigVersion = require_urlsParser.getQueryParam("spiffy_config_version") || require_urlsParser.getQueryParam("envive_config_version") || void 0;
+		const widgetTextRequest = {
+			requestId: (0, uuid.v4)(),
+			widgetType: request.widgetType,
+			context: this.config.getAppDetails(),
+			featureFlags: this.config.getFeatureFlags(),
+			language: navigator.languages[0] || "en",
+			overrideConfigVersion,
+			url: window.location.href
+		};
+		this.config.trackEvent?.({
+			eventName: require_eventNames.EnviveMetricsEventName.WidgetTextRequest,
+			eventProps: {
+				widget_type: request.widgetType,
+				request_id: widgetTextRequest.requestId
+			}
+		});
+		try {
+			const response = await require_application_commerce_api.default.getHardcopy(widgetTextRequest);
+			if (response) {
+				const convertedResponse = convertToHardcopyResponse(response);
+				logger.logDebug("converted response", convertedResponse);
+				this.config.trackEvent?.({
+					eventName: require_eventNames.EnviveMetricsEventName.WidgetTextResponse,
+					eventProps: {
+						widget_type: request.widgetType,
+						response_id: response.responseId,
+						widget_text: response.values,
+						request_id: widgetTextRequest.requestId
+					}
+				});
+				return convertedResponse;
+			}
+		} catch (error) {
+			logger.logError("error getting hardcopy from backend", error);
+		}
+		const mockResponse = MOCK_HARDCOPY_RESPONSE[request.widgetType];
+		if (mockResponse) {
+			logger.logDebug("no real response, using mock", mockResponse);
+			return mockResponse;
+		}
+		throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);
+	}
+};
+var MockHardcopyService = class {
+	constructor(overrides = {}) {
+		this.overrides = overrides;
+	}
+	async getHardcopy(request) {
+		const fallbackWidgetType = request.widgetType === require_contexts_typesV3.WidgetTypeV3.ProductCardV3 ? require_contexts_typesV3.WidgetTypeV3.ImagePromptCardV3 : request.widgetType;
+		const response = this.overrides[request.widgetType] ?? this.overrides[fallbackWidgetType] ?? MOCK_HARDCOPY_RESPONSE[request.widgetType];
+		if (!response) throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);
+		return response;
+	}
+};
+
+//#endregion
+exports.HardcopyService = HardcopyService;
+exports.MOCK_HARDCOPY_RESPONSE = MOCK_HARDCOPY_RESPONSE;
+exports.MockHardcopyService = MockHardcopyService;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"hardcopyService.cjs","names":["Logger","MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>>","WidgetTypeV3","toCamelCase","config: HardcopyServiceConfig","getQueryParam","widgetTextRequest: WidgetTextRequest","EnviveMetricsEventName","CommerceApiClient","overrides: Partial<Record<WidgetTypeV3, HardcopyResponse>>"],"sources":["../../../src/services/hardcopyService/hardcopyService.ts"],"sourcesContent":["import { v4 as uuid } from 'uuid';\nimport CommerceApiClient from 'src/application/commerce-api';\nimport { WidgetString, WidgetText } from 'src/application/models/api/widgetText';\nimport { WidgetTextRequest } from 'src/application/models/api/widgetTextRequest';\nimport { toCamelCase } from 'src/application/models/utils/snakeToCamelTransformer';\nimport { getQueryParam } from 'src/application/utils';\nimport { UserEvent } from 'src/application/models';\nimport Logger from 'src/application/logging/logger';\nimport { AppDetails } from 'src/atoms/app';\nimport { WidgetTypeV3 } from 'src/contexts/typesV3';\nimport { EnviveMetricsEventName, TrackEventParams } from '../amplitudeService';\n\nconst logger = new Logger('hardcopyService');\n\nexport interface HardcopyRequest {\n  widgetType: WidgetTypeV3;\n  userEvent: UserEvent;\n}\n\nexport type HardcopyResponse = {\n  responseId: string;\n  language: string;\n  rawValues?: Record<string, WidgetString | WidgetString[]>;\n  values: Record<string, string | string[]>;\n};\n\nexport interface IHardcopyService {\n  getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse>;\n}\n\nexport interface HardcopyServiceConfig {\n  getAppDetails: () => AppDetails;\n  getFeatureFlags: () => Record<string, boolean>;\n  trackEvent?: (params: TrackEventParams) => Promise<void>;\n}\n\n// Sample responses used both as fallback when the backend fails and by MockHardcopyService.\nexport const MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {\n  [WidgetTypeV3.PromptCarouselV3]: {\n    responseId: uuid(),\n    language: 'en',\n    values: {\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n    },\n  },\n  [WidgetTypeV3.TitledPromptCarouselV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Need some help?',\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n    },\n  },\n  [WidgetTypeV3.SocialProofV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      numberOfCustomersText: '123 customers',\n      customerQueryText: 'found what they were looking for...',\n      primaryButtonText: 'Start shopping',\n      secondaryButtonTitleText: 'Popular searches',\n      secondaryButtonTexts: [\n        'Why should I buy from you?',\n        'How do I return an item?',\n        'New arrivals',\n        'Sale items',\n        'Popular items',\n      ],\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.TypingAnimationV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      headlineText: 'Need help finding',\n      animatedTextSequence: [\n        'the perfect gift for your loved ones?',\n        'something special for the holidays?',\n        'the ideal present for someone special?',\n      ],\n      hintText: 'Ask me anything',\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n      ],\n      textFieldAriaLabel: 'Ask me anything',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewComparisonV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      headlineText: 'Need help comparing?',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewLoadingV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.PromptButtonCarouselWithImageV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Need some help?',\n      promptButtonsTexts: ['Help me find a product', \"What's on your mind?\", 'Talk to a human'],\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ProductCardV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      headline: 'Discover Your Perfect Style',\n      animatedText: [\n        'the perfect outfit for any occasion',\n        'trending fashion that fits your lifestyle',\n        'quality pieces that last',\n      ],\n      prompts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n      placeholder: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.FloatingChatV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      welcomeMessageTitle: 'Welcome to Envive AI',\n      welcomeMessageText:\n        'Your personal shopper trained on the collective knowledge of thousands of real experts!',\n      chatFooterTextFieldPlaceholderText: 'Ask me anything...',\n      disclaimerText: 'This is a disclaimer...',\n      leftToggleLabel: 'Shop with AI',\n      rightToggleLabel: 'Live support',\n    },\n  },\n  [WidgetTypeV3.FullPageSalesAgentV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      welcomeMessageTitle: 'Welcome to Envive AI',\n      welcomeMessageText:\n        'Your personal shopper trained on the collective knowledge of thousands of real experts!',\n      chatFooterTextFieldPlaceholderText: 'Ask me anything...',\n      disclaimerText: 'This is a disclaimer...',\n    },\n  },\n};\n\nconst convertToHardcopyResponse = (response: WidgetText): HardcopyResponse => ({\n  responseId: response.responseId,\n  language: response.language,\n  rawValues: response.values,\n  values: Object.fromEntries(\n    Object.entries(response.values).map(([key, value]) => [\n      toCamelCase(key),\n      value.length === 1 ? value[0].value : value.map(v => v.value),\n    ]),\n  ),\n});\n\nexport class HardcopyService implements IHardcopyService {\n  constructor(private config: HardcopyServiceConfig) {}\n\n  async getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse> {\n    const overrideConfigVersion =\n      getQueryParam('spiffy_config_version') || getQueryParam('envive_config_version') || undefined;\n\n    const widgetTextRequest: WidgetTextRequest = {\n      requestId: uuid(),\n      widgetType: request.widgetType,\n      context: this.config.getAppDetails(),\n      featureFlags: this.config.getFeatureFlags(),\n      language: navigator.languages[0] || 'en',\n      overrideConfigVersion,\n      url: window.location.href,\n    };\n\n    this.config.trackEvent?.({\n      eventName: EnviveMetricsEventName.WidgetTextRequest,\n      eventProps: {\n        widget_type: request.widgetType,\n        request_id: widgetTextRequest.requestId,\n      },\n    });\n\n    try {\n      const response = await CommerceApiClient.getHardcopy(widgetTextRequest);\n      if (response) {\n        const convertedResponse = convertToHardcopyResponse(response);\n        logger.logDebug('converted response', convertedResponse);\n        this.config.trackEvent?.({\n          eventName: EnviveMetricsEventName.WidgetTextResponse,\n          eventProps: {\n            widget_type: request.widgetType,\n            response_id: response.responseId,\n            widget_text: response.values,\n            request_id: widgetTextRequest.requestId,\n          },\n        });\n        return convertedResponse;\n      }\n    } catch (error) {\n      logger.logError('error getting hardcopy from backend', error);\n    }\n\n    const mockResponse = MOCK_HARDCOPY_RESPONSE[request.widgetType];\n    if (mockResponse) {\n      logger.logDebug('no real response, using mock', mockResponse);\n      return mockResponse;\n    }\n    throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n  }\n}\n\nexport class MockHardcopyService implements IHardcopyService {\n  constructor(private overrides: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {}) {}\n\n  async getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse> {\n    const fallbackWidgetType =\n      request.widgetType === WidgetTypeV3.ProductCardV3\n        ? WidgetTypeV3.ImagePromptCardV3\n        : request.widgetType;\n\n    const response =\n      this.overrides[request.widgetType] ??\n      this.overrides[fallbackWidgetType] ??\n      MOCK_HARDCOPY_RESPONSE[request.widgetType];\n\n    if (!response) {\n      throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n    }\n    return response;\n  }\n}\n"],"mappings":"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"}

package/dist/services/hardcopyService/hardcopyService.d.cts

@@ -0,0 +1,39 @@
+import { WidgetTypeV3 } from "../../contexts/typesV3.cjs";
+import { WidgetString } from "../../application/models/api/widgetText.cjs";
+import { AppDetails } from "../../atoms/app/index.cjs";
+import { TrackEventParams } from "../amplitudeService/amplitudeService.cjs";
+import { UserEvent } from "../../application/models/api/userEvent.cjs";
+
+//#region src/services/hardcopyService/hardcopyService.d.ts
+interface HardcopyRequest {
+  widgetType: WidgetTypeV3;
+  userEvent: UserEvent;
+}
+type HardcopyResponse = {
+  responseId: string;
+  language: string;
+  rawValues?: Record<string, WidgetString | WidgetString[]>;
+  values: Record<string, string | string[]>;
+};
+interface IHardcopyService {
+  getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse>;
+}
+interface HardcopyServiceConfig {
+  getAppDetails: () => AppDetails;
+  getFeatureFlags: () => Record<string, boolean>;
+  trackEvent?: (params: TrackEventParams) => Promise<void>;
+}
+declare const MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>>;
+declare class HardcopyService implements IHardcopyService {
+  private config;
+  constructor(config: HardcopyServiceConfig);
+  getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse>;
+}
+declare class MockHardcopyService implements IHardcopyService {
+  private overrides;
+  constructor(overrides?: Partial<Record<WidgetTypeV3, HardcopyResponse>>);
+  getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse>;
+}
+//#endregion
+export { HardcopyRequest, HardcopyResponse, HardcopyService, HardcopyServiceConfig, IHardcopyService, MOCK_HARDCOPY_RESPONSE, MockHardcopyService };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/services/hardcopyService/hardcopyService.d.ts

@@ -0,0 +1,39 @@
+import { WidgetTypeV3 } from "../../contexts/typesV3.js";
+import { WidgetString } from "../../application/models/api/widgetText.js";
+import { AppDetails } from "../../atoms/app/index.js";
+import { TrackEventParams } from "../amplitudeService/amplitudeService.js";
+import { UserEvent } from "../../application/models/api/userEvent.js";
+
+//#region src/services/hardcopyService/hardcopyService.d.ts
+interface HardcopyRequest {
+  widgetType: WidgetTypeV3;
+  userEvent: UserEvent;
+}
+type HardcopyResponse = {
+  responseId: string;
+  language: string;
+  rawValues?: Record<string, WidgetString | WidgetString[]>;
+  values: Record<string, string | string[]>;
+};
+interface IHardcopyService {
+  getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse>;
+}
+interface HardcopyServiceConfig {
+  getAppDetails: () => AppDetails;
+  getFeatureFlags: () => Record<string, boolean>;
+  trackEvent?: (params: TrackEventParams) => Promise<void>;
+}
+declare const MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>>;
+declare class HardcopyService implements IHardcopyService {
+  private config;
+  constructor(config: HardcopyServiceConfig);
+  getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse>;
+}
+declare class MockHardcopyService implements IHardcopyService {
+  private overrides;
+  constructor(overrides?: Partial<Record<WidgetTypeV3, HardcopyResponse>>);
+  getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse>;
+}
+//#endregion
+export { HardcopyRequest, HardcopyResponse, HardcopyService, HardcopyServiceConfig, IHardcopyService, MOCK_HARDCOPY_RESPONSE, MockHardcopyService };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/services/hardcopyService/hardcopyService.js

@@ -0,0 +1,229 @@
+import logger_default from "../../application/logging/logger.js";
+import { getQueryParam } from "../../application/utils/urlsParser.js";
+import { toCamelCase } from "../../application/models/utils/snakeToCamelTransformer.js";
+import { WidgetTypeV3 } from "../../contexts/typesV3.js";
+import { EnviveMetricsEventName } from "../amplitudeService/eventNames.js";
+import "../../application/utils/index.js";
+import commerce_api_default from "../../application/commerce-api.js";
+import "../amplitudeService/index.js";
+import { v4 } from "uuid";
+
+//#region src/services/hardcopyService/hardcopyService.ts
+const logger = new logger_default("hardcopyService");
+const MOCK_HARDCOPY_RESPONSE = {
+	[WidgetTypeV3.PromptCarouselV3]: {
+		responseId: v4(),
+		language: "en",
+		values: { promptButtonTexts: [
+			"What are your best sellers?",
+			"Show me summer dresses",
+			"Do you have free shipping?",
+			"What sizes are available?",
+			"Can I return items?"
+		] }
+	},
+	[WidgetTypeV3.TitledPromptCarouselV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			titleLabel: "Need some help?",
+			promptButtonTexts: [
+				"What are your best sellers?",
+				"Show me summer dresses",
+				"Do you have free shipping?",
+				"What sizes are available?",
+				"Can I return items?"
+			]
+		}
+	},
+	[WidgetTypeV3.SocialProofV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			titleLabel: "Shopping Assistant",
+			numberOfCustomersText: "123 customers",
+			customerQueryText: "found what they were looking for...",
+			primaryButtonText: "Start shopping",
+			secondaryButtonTitleText: "Popular searches",
+			secondaryButtonTexts: [
+				"Why should I buy from you?",
+				"How do I return an item?",
+				"New arrivals",
+				"Sale items",
+				"Popular items"
+			],
+			textFieldPlaceholderText: "Ask me anything..."
+		}
+	},
+	[WidgetTypeV3.TypingAnimationV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			titleLabel: "Shopping Assistant",
+			headlineText: "Need help finding",
+			animatedTextSequence: [
+				"the perfect gift for your loved ones?",
+				"something special for the holidays?",
+				"the ideal present for someone special?"
+			],
+			hintText: "Ask me anything",
+			promptButtonTexts: [
+				"What are your best sellers?",
+				"Show me summer dresses",
+				"Do you have free shipping?",
+				"What sizes are available?"
+			],
+			textFieldAriaLabel: "Ask me anything"
+		}
+	},
+	[WidgetTypeV3.ChatPreviewComparisonV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			titleLabel: "Shopping Assistant",
+			headlineText: "Need help comparing?",
+			textFieldPlaceholderText: "Ask me anything..."
+		}
+	},
+	[WidgetTypeV3.ChatPreviewLoadingV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			titleLabel: "Shopping Assistant",
+			textFieldPlaceholderText: "Ask me anything..."
+		}
+	},
+	[WidgetTypeV3.ChatPreviewV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			titleLabel: "Shopping Assistant",
+			textFieldPlaceholderText: "Ask me anything..."
+		}
+	},
+	[WidgetTypeV3.PromptButtonCarouselWithImageV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			titleLabel: "Need some help?",
+			promptButtonsTexts: [
+				"Help me find a product",
+				"What's on your mind?",
+				"Talk to a human"
+			],
+			textFieldPlaceholderText: "Ask me anything..."
+		}
+	},
+	[WidgetTypeV3.ProductCardV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			headline: "Discover Your Perfect Style",
+			animatedText: [
+				"the perfect outfit for any occasion",
+				"trending fashion that fits your lifestyle",
+				"quality pieces that last"
+			],
+			prompts: [
+				"What are your best sellers?",
+				"Show me summer dresses",
+				"Do you have free shipping?",
+				"What sizes are available?",
+				"Can I return items?"
+			],
+			placeholder: "Ask me anything..."
+		}
+	},
+	[WidgetTypeV3.FloatingChatV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			welcomeMessageTitle: "Welcome to Envive AI",
+			welcomeMessageText: "Your personal shopper trained on the collective knowledge of thousands of real experts!",
+			chatFooterTextFieldPlaceholderText: "Ask me anything...",
+			disclaimerText: "This is a disclaimer...",
+			leftToggleLabel: "Shop with AI",
+			rightToggleLabel: "Live support"
+		}
+	},
+	[WidgetTypeV3.FullPageSalesAgentV3]: {
+		responseId: "mock-response-id",
+		language: "en",
+		values: {
+			welcomeMessageTitle: "Welcome to Envive AI",
+			welcomeMessageText: "Your personal shopper trained on the collective knowledge of thousands of real experts!",
+			chatFooterTextFieldPlaceholderText: "Ask me anything...",
+			disclaimerText: "This is a disclaimer..."
+		}
+	}
+};
+const convertToHardcopyResponse = (response) => ({
+	responseId: response.responseId,
+	language: response.language,
+	rawValues: response.values,
+	values: Object.fromEntries(Object.entries(response.values).map(([key, value]) => [toCamelCase(key), value.length === 1 ? value[0].value : value.map((v) => v.value)]))
+});
+var HardcopyService = class {
+	constructor(config) {
+		this.config = config;
+	}
+	async getHardcopy(request) {
+		const overrideConfigVersion = getQueryParam("spiffy_config_version") || getQueryParam("envive_config_version") || void 0;
+		const widgetTextRequest = {
+			requestId: v4(),
+			widgetType: request.widgetType,
+			context: this.config.getAppDetails(),
+			featureFlags: this.config.getFeatureFlags(),
+			language: navigator.languages[0] || "en",
+			overrideConfigVersion,
+			url: window.location.href
+		};
+		this.config.trackEvent?.({
+			eventName: EnviveMetricsEventName.WidgetTextRequest,
+			eventProps: {
+				widget_type: request.widgetType,
+				request_id: widgetTextRequest.requestId
+			}
+		});
+		try {
+			const response = await commerce_api_default.getHardcopy(widgetTextRequest);
+			if (response) {
+				const convertedResponse = convertToHardcopyResponse(response);
+				logger.logDebug("converted response", convertedResponse);
+				this.config.trackEvent?.({
+					eventName: EnviveMetricsEventName.WidgetTextResponse,
+					eventProps: {
+						widget_type: request.widgetType,
+						response_id: response.responseId,
+						widget_text: response.values,
+						request_id: widgetTextRequest.requestId
+					}
+				});
+				return convertedResponse;
+			}
+		} catch (error) {
+			logger.logError("error getting hardcopy from backend", error);
+		}
+		const mockResponse = MOCK_HARDCOPY_RESPONSE[request.widgetType];
+		if (mockResponse) {
+			logger.logDebug("no real response, using mock", mockResponse);
+			return mockResponse;
+		}
+		throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);
+	}
+};
+var MockHardcopyService = class {
+	constructor(overrides = {}) {
+		this.overrides = overrides;
+	}
+	async getHardcopy(request) {
+		const fallbackWidgetType = request.widgetType === WidgetTypeV3.ProductCardV3 ? WidgetTypeV3.ImagePromptCardV3 : request.widgetType;
+		const response = this.overrides[request.widgetType] ?? this.overrides[fallbackWidgetType] ?? MOCK_HARDCOPY_RESPONSE[request.widgetType];
+		if (!response) throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);
+		return response;
+	}
+};
+
+//#endregion
+export { HardcopyService, MOCK_HARDCOPY_RESPONSE, MockHardcopyService };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"hardcopyService.js","names":["Logger","MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>>","uuid","config: HardcopyServiceConfig","widgetTextRequest: WidgetTextRequest","CommerceApiClient","overrides: Partial<Record<WidgetTypeV3, HardcopyResponse>>"],"sources":["../../../src/services/hardcopyService/hardcopyService.ts"],"sourcesContent":["import { v4 as uuid } from 'uuid';\nimport CommerceApiClient from 'src/application/commerce-api';\nimport { WidgetString, WidgetText } from 'src/application/models/api/widgetText';\nimport { WidgetTextRequest } from 'src/application/models/api/widgetTextRequest';\nimport { toCamelCase } from 'src/application/models/utils/snakeToCamelTransformer';\nimport { getQueryParam } from 'src/application/utils';\nimport { UserEvent } from 'src/application/models';\nimport Logger from 'src/application/logging/logger';\nimport { AppDetails } from 'src/atoms/app';\nimport { WidgetTypeV3 } from 'src/contexts/typesV3';\nimport { EnviveMetricsEventName, TrackEventParams } from '../amplitudeService';\n\nconst logger = new Logger('hardcopyService');\n\nexport interface HardcopyRequest {\n  widgetType: WidgetTypeV3;\n  userEvent: UserEvent;\n}\n\nexport type HardcopyResponse = {\n  responseId: string;\n  language: string;\n  rawValues?: Record<string, WidgetString | WidgetString[]>;\n  values: Record<string, string | string[]>;\n};\n\nexport interface IHardcopyService {\n  getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse>;\n}\n\nexport interface HardcopyServiceConfig {\n  getAppDetails: () => AppDetails;\n  getFeatureFlags: () => Record<string, boolean>;\n  trackEvent?: (params: TrackEventParams) => Promise<void>;\n}\n\n// Sample responses used both as fallback when the backend fails and by MockHardcopyService.\nexport const MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {\n  [WidgetTypeV3.PromptCarouselV3]: {\n    responseId: uuid(),\n    language: 'en',\n    values: {\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n    },\n  },\n  [WidgetTypeV3.TitledPromptCarouselV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Need some help?',\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n    },\n  },\n  [WidgetTypeV3.SocialProofV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      numberOfCustomersText: '123 customers',\n      customerQueryText: 'found what they were looking for...',\n      primaryButtonText: 'Start shopping',\n      secondaryButtonTitleText: 'Popular searches',\n      secondaryButtonTexts: [\n        'Why should I buy from you?',\n        'How do I return an item?',\n        'New arrivals',\n        'Sale items',\n        'Popular items',\n      ],\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.TypingAnimationV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      headlineText: 'Need help finding',\n      animatedTextSequence: [\n        'the perfect gift for your loved ones?',\n        'something special for the holidays?',\n        'the ideal present for someone special?',\n      ],\n      hintText: 'Ask me anything',\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n      ],\n      textFieldAriaLabel: 'Ask me anything',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewComparisonV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      headlineText: 'Need help comparing?',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewLoadingV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.PromptButtonCarouselWithImageV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Need some help?',\n      promptButtonsTexts: ['Help me find a product', \"What's on your mind?\", 'Talk to a human'],\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ProductCardV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      headline: 'Discover Your Perfect Style',\n      animatedText: [\n        'the perfect outfit for any occasion',\n        'trending fashion that fits your lifestyle',\n        'quality pieces that last',\n      ],\n      prompts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n      placeholder: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.FloatingChatV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      welcomeMessageTitle: 'Welcome to Envive AI',\n      welcomeMessageText:\n        'Your personal shopper trained on the collective knowledge of thousands of real experts!',\n      chatFooterTextFieldPlaceholderText: 'Ask me anything...',\n      disclaimerText: 'This is a disclaimer...',\n      leftToggleLabel: 'Shop with AI',\n      rightToggleLabel: 'Live support',\n    },\n  },\n  [WidgetTypeV3.FullPageSalesAgentV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      welcomeMessageTitle: 'Welcome to Envive AI',\n      welcomeMessageText:\n        'Your personal shopper trained on the collective knowledge of thousands of real experts!',\n      chatFooterTextFieldPlaceholderText: 'Ask me anything...',\n      disclaimerText: 'This is a disclaimer...',\n    },\n  },\n};\n\nconst convertToHardcopyResponse = (response: WidgetText): HardcopyResponse => ({\n  responseId: response.responseId,\n  language: response.language,\n  rawValues: response.values,\n  values: Object.fromEntries(\n    Object.entries(response.values).map(([key, value]) => [\n      toCamelCase(key),\n      value.length === 1 ? value[0].value : value.map(v => v.value),\n    ]),\n  ),\n});\n\nexport class HardcopyService implements IHardcopyService {\n  constructor(private config: HardcopyServiceConfig) {}\n\n  async getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse> {\n    const overrideConfigVersion =\n      getQueryParam('spiffy_config_version') || getQueryParam('envive_config_version') || undefined;\n\n    const widgetTextRequest: WidgetTextRequest = {\n      requestId: uuid(),\n      widgetType: request.widgetType,\n      context: this.config.getAppDetails(),\n      featureFlags: this.config.getFeatureFlags(),\n      language: navigator.languages[0] || 'en',\n      overrideConfigVersion,\n      url: window.location.href,\n    };\n\n    this.config.trackEvent?.({\n      eventName: EnviveMetricsEventName.WidgetTextRequest,\n      eventProps: {\n        widget_type: request.widgetType,\n        request_id: widgetTextRequest.requestId,\n      },\n    });\n\n    try {\n      const response = await CommerceApiClient.getHardcopy(widgetTextRequest);\n      if (response) {\n        const convertedResponse = convertToHardcopyResponse(response);\n        logger.logDebug('converted response', convertedResponse);\n        this.config.trackEvent?.({\n          eventName: EnviveMetricsEventName.WidgetTextResponse,\n          eventProps: {\n            widget_type: request.widgetType,\n            response_id: response.responseId,\n            widget_text: response.values,\n            request_id: widgetTextRequest.requestId,\n          },\n        });\n        return convertedResponse;\n      }\n    } catch (error) {\n      logger.logError('error getting hardcopy from backend', error);\n    }\n\n    const mockResponse = MOCK_HARDCOPY_RESPONSE[request.widgetType];\n    if (mockResponse) {\n      logger.logDebug('no real response, using mock', mockResponse);\n      return mockResponse;\n    }\n    throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n  }\n}\n\nexport class MockHardcopyService implements IHardcopyService {\n  constructor(private overrides: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {}) {}\n\n  async getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse> {\n    const fallbackWidgetType =\n      request.widgetType === WidgetTypeV3.ProductCardV3\n        ? WidgetTypeV3.ImagePromptCardV3\n        : request.widgetType;\n\n    const response =\n      this.overrides[request.widgetType] ??\n      this.overrides[fallbackWidgetType] ??\n      MOCK_HARDCOPY_RESPONSE[request.widgetType];\n\n    if (!response) {\n      throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n    }\n    return response;\n  }\n}\n"],"mappings":"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"}

package/dist/services/hardcopyService/index.cjs

@@ -0,0 +1,5 @@
+const require_hardcopyService = require('./hardcopyService.cjs');
+
+exports.HardcopyService = require_hardcopyService.HardcopyService;
+exports.MOCK_HARDCOPY_RESPONSE = require_hardcopyService.MOCK_HARDCOPY_RESPONSE;
+exports.MockHardcopyService = require_hardcopyService.MockHardcopyService;

package/dist/services/hardcopyService/index.d.cts

@@ -0,0 +1,2 @@
+import { HardcopyRequest, HardcopyResponse, HardcopyService, HardcopyServiceConfig, IHardcopyService, MOCK_HARDCOPY_RESPONSE, MockHardcopyService } from "./hardcopyService.cjs";
+export { HardcopyRequest, HardcopyResponse, HardcopyService, HardcopyServiceConfig, IHardcopyService, MOCK_HARDCOPY_RESPONSE, MockHardcopyService };

package/dist/services/hardcopyService/index.d.ts

@@ -0,0 +1,2 @@
+import { HardcopyRequest, HardcopyResponse, HardcopyService, HardcopyServiceConfig, IHardcopyService, MOCK_HARDCOPY_RESPONSE, MockHardcopyService } from "./hardcopyService.js";
+export { HardcopyRequest, HardcopyResponse, HardcopyService, HardcopyServiceConfig, IHardcopyService, MOCK_HARDCOPY_RESPONSE, MockHardcopyService };

package/dist/services/hardcopyService/index.js

@@ -0,0 +1,3 @@
+import { HardcopyService, MOCK_HARDCOPY_RESPONSE, MockHardcopyService } from "./hardcopyService.js";
+
+export { HardcopyService, MOCK_HARDCOPY_RESPONSE, MockHardcopyService };

package/dist/services/userIdentityService/index.cjs

@@ -1,3 +1,4 @@
 const require_userIdentityService = require('./userIdentityService.cjs');
 
+exports.MockUserIdentityService = require_userIdentityService.MockUserIdentityService;
 exports.UserIdentityService = require_userIdentityService.UserIdentityService;

package/dist/services/userIdentityService/index.d.cts

@@ -1,2 +1,2 @@
-import { UserIdentityService } from "./userIdentityService.cjs";
-export { UserIdentityService };
+import { IUserIdentityService, MockUserIdentityService, UserIdentityService } from "./userIdentityService.cjs";
+export { IUserIdentityService, MockUserIdentityService, UserIdentityService };

package/dist/services/userIdentityService/index.d.ts

@@ -1,2 +1,2 @@
-import { UserIdentityService } from "./userIdentityService.js";
-export { UserIdentityService };
+import { IUserIdentityService, MockUserIdentityService, UserIdentityService } from "./userIdentityService.js";
+export { IUserIdentityService, MockUserIdentityService, UserIdentityService };

package/dist/services/userIdentityService/index.js

@@ -1,3 +1,3 @@
-import { UserIdentityService } from "./userIdentityService.js";
+import { MockUserIdentityService, UserIdentityService } from "./userIdentityService.js";
 
-export { UserIdentityService };
+export { MockUserIdentityService, UserIdentityService };