@envive-ai/react-hooks 0.3.2 → 0.3.4

package/dist/contexts/graphqlContext/mockV3Config.js

@@ -0,0 +1,207 @@
+import { ConfigVersionEnum, SocialProofWidgetKind, WidgetTypeV3 } from "../typesV3.js";
+import { ColorNames, colorVar } from "../../application/models/colorsConfigV3.js";
+import { ImageGalleryLayout } from "../../packages/components-v3/dist/ImageGallery/types/types.js";
+import "../../packages/components-v3/dist/ImageGallery/index.js";
+import { PromptButtonVariant } from "../../packages/components-v3/dist/PromptButton/types/index.js";
+import "../../packages/components-v3/dist/PromptButton/index.js";
+import { AnimationSpeed, PromptCarouselRows } from "../../packages/components-v3/dist/PromptCarousel/types/types.js";
+import "../../packages/components-v3/dist/PromptCarousel/index.js";
+import { WidgetWrapperVariant } from "../../packages/components-v3/dist/WidgetWrapper/types/types.js";
+import "../../packages/components-v3/dist/WidgetWrapper/index.js";
+
+//#region src/contexts/graphqlContext/mockV3Config.ts
+const mockImages = [
+	{
+		src: "https://picsum.photos/400/600",
+		alt: "Image 1"
+	},
+	{
+		src: "https://picsum.photos/400/600",
+		alt: "Image 2"
+	},
+	{
+		src: "https://picsum.photos/400/600",
+		alt: "Image 3"
+	},
+	{
+		src: "https://picsum.photos/400/600",
+		alt: "Image 4"
+	}
+];
+const mockV3ColorsConfig = {
+	textPrimary: "#021414",
+	textSecondary: "#666666",
+	textAccent: "#478D87",
+	textLink: "#042E2C",
+	textLight: "#FFFFFF",
+	backgroundPrimary: "#1F5F51",
+	backgroundSecondary: "#F9F6EA",
+	backgroundTertiary: "#EEECDD",
+	backgroundDark: "#021414",
+	backgroundLight: "#FFFFFF",
+	borderLight: "#E6E7E7",
+	borderMedium: "#B3B8B8",
+	borderDark: "#021414",
+	accentPrimary: "#1F5F51",
+	accentSecondary: "#AE8659"
+};
+const mockV3FrontendConfig = {
+	uiConfigs: {
+		version: ConfigVersionEnum.V3,
+		shortName: "Envive AI",
+		lookAndFeel: {
+			theme: "standard",
+			agentName: "Envive AI",
+			chatHeaderLogoSrc: "https://cdn.spiffy.ai/other/assets/envive-ai/Envive_Logo_Lt.svg",
+			widgetLogoSrc: "https://cdn.spiffy.ai/other/assets/envive-ai/Envive_Logo_DK.svg",
+			hideWidgetLogo: false,
+			elementRadius: 8,
+			imageAspectRatio: "3/4",
+			buttonColors: {
+				lightButtonBackgroundColor: colorVar(ColorNames.BackgroundSecondary),
+				lightButtonIconColor: colorVar(ColorNames.AccentPrimary),
+				darkButtonBackgroundColor: colorVar(ColorNames.BackgroundDark),
+				darkButtonIconColor: colorVar(ColorNames.AccentPrimary)
+			},
+			typography: {
+				titleFontFamily: "Poppins",
+				headerFontFamily: "Poppins",
+				bodyFontFamily: "Inter Variable",
+				fontSize: {
+					t1: "32px",
+					t2: "28px",
+					t3: "24px",
+					h1: "20px",
+					h2: "16px",
+					h3: "14px",
+					b1: "20px",
+					b2: "16px",
+					b3: "14px",
+					b4: "12px",
+					b5: "10px",
+					l1: "14px",
+					l2: "12px"
+				},
+				fontWeight: {
+					rg: "400",
+					md: "500",
+					sb: "600"
+				},
+				letterSpacing: {
+					"0": "0em",
+					"wide-1": "1px"
+				},
+				lineHeight: {
+					"124": 1.24,
+					"120": 1.2,
+					"118": 1.18,
+					"116": 1.16,
+					"114": 1.14,
+					"148": 1.48,
+					"140": 1.4,
+					"128": 1.28,
+					"130": 1.3,
+					"133": 1.33
+				}
+			}
+		},
+		floatingButton: {
+			position: "bottom-right",
+			backgroundColor: colorVar(ColorNames.BackgroundPrimary),
+			mode: "light",
+			showOption: "always",
+			style: "attached",
+			iconSVGSrc: ""
+		},
+		floatingChat: {
+			headerBackgroundColor: colorVar(ColorNames.BackgroundPrimary),
+			headerMode: "dark",
+			welcomeMessageIconColor: colorVar(ColorNames.AccentPrimary),
+			showVerifiedBuyer: false,
+			userCanEditQueries: true,
+			showEnviveLogo: true,
+			ignoreFirstModelResponse: false,
+			neverShowSingleProductCards: false
+		}
+	},
+	pageVariants: [],
+	mountingConfigs: {},
+	widgetConfigs: {
+		"prompt-carousel-test-light-widget": {
+			widgetConfigId: "prompt-carousel-test-light-widget",
+			contentId: "prompt-carousel-test-light-widget",
+			type: WidgetTypeV3.PromptCarouselV3,
+			promptButtonType: PromptButtonVariant.LIGHT,
+			boldFirstButton: false,
+			promptCarouselRows: PromptCarouselRows.ALWAYS_ONE,
+			animationSpeed: AnimationSpeed.FAST
+		},
+		"prompt-carousel-test-dark-widget": {
+			widgetConfigId: "prompt-carousel-test-dark-widget",
+			contentId: "prompt-carousel-test-dark-widget",
+			type: WidgetTypeV3.PromptCarouselV3,
+			promptButtonType: PromptButtonVariant.DARK,
+			boldFirstButton: false,
+			promptCarouselRows: PromptCarouselRows.ALWAYS_ONE,
+			animationSpeed: AnimationSpeed.FAST
+		},
+		"titled-prompt-carousel-test-light-widget": {
+			widgetConfigId: "titled-prompt-carousel-test-light-widget",
+			contentId: "titled-prompt-carousel-test-light-widget",
+			type: WidgetTypeV3.TitledPromptCarouselV3,
+			promptButtonType: PromptButtonVariant.LIGHT,
+			boldFirstButton: false,
+			promptCarouselRows: PromptCarouselRows.ALWAYS_ONE,
+			animationSpeed: AnimationSpeed.FAST
+		},
+		"titled-prompt-carousel-test-dark-widget": {
+			widgetConfigId: "titled-prompt-carousel-test-dark-widget",
+			contentId: "titled-prompt-carousel-test-dark-widget",
+			type: WidgetTypeV3.TitledPromptCarouselV3,
+			promptButtonType: PromptButtonVariant.DARK,
+			boldFirstButton: false,
+			promptCarouselRows: PromptCarouselRows.ALWAYS_ONE,
+			animationSpeed: AnimationSpeed.FAST
+		},
+		"social-proof-test-widget-four-grid": {
+			widgetConfigId: "social-proof-test-widget-four-grid",
+			contentId: "social-proof-test-widget-four-grid",
+			type: WidgetTypeV3.SocialProofV3,
+			imageGalleryLayout: ImageGalleryLayout.FOUR_GRID,
+			kind: SocialProofWidgetKind.STATIC,
+			variant: WidgetWrapperVariant.INLINE_WITH_BORDER,
+			promptCarouselRows: PromptCarouselRows.TWO_ON_MOBILE_ONE_ON_DESKTOP,
+			primaryButtonVariant: PromptButtonVariant.DARK,
+			secondaryButtonVariant: PromptButtonVariant.LIGHT,
+			images: mockImages
+		},
+		"social-proof-test-widget-single": {
+			widgetConfigId: "social-proof-test-widget-single",
+			contentId: "social-proof-test-widget-single",
+			type: WidgetTypeV3.SocialProofV3,
+			imageGalleryLayout: ImageGalleryLayout.SINGLE,
+			kind: SocialProofWidgetKind.STATIC,
+			variant: WidgetWrapperVariant.CARD_NO_BORDER,
+			promptCarouselRows: PromptCarouselRows.TWO_ON_MOBILE_ONE_ON_DESKTOP,
+			primaryButtonVariant: PromptButtonVariant.DARK,
+			secondaryButtonVariant: PromptButtonVariant.LIGHT,
+			images: mockImages
+		},
+		"social-proof-test-widget-four-horizontal": {
+			widgetConfigId: "social-proof-test-widget-four-horizontal",
+			contentId: "social-proof-test-widget-four-horizontal",
+			type: WidgetTypeV3.SocialProofV3,
+			imageGalleryLayout: ImageGalleryLayout.FOUR_HORIZONTAL,
+			kind: SocialProofWidgetKind.STATIC,
+			variant: WidgetWrapperVariant.CARD_WITH_BORDER,
+			promptCarouselRows: PromptCarouselRows.TWO_ON_MOBILE_ONE_ON_DESKTOP,
+			primaryButtonVariant: PromptButtonVariant.DARK,
+			secondaryButtonVariant: PromptButtonVariant.LIGHT,
+			images: mockImages
+		}
+	}
+};
+
+//#endregion
+export { mockV3ColorsConfig, mockV3FrontendConfig };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"mockV3Config.js","names":["mockV3ColorsConfig: CamelCasedPropertiesDeep<ColorMappingV3>","mockV3FrontendConfig: FrontendConfigV3"],"sources":["../../../src/contexts/graphqlContext/mockV3Config.ts"],"sourcesContent":["import { FrontendConfigV3 } from 'src/application/models/frontendConfigV3';\nimport { ColorMappingV3, ColorNames, colorVar } from 'src/application/models/colorsConfigV3';\nimport { CamelCasedPropertiesDeep } from 'src/application/models';\nimport { ImageGalleryLayout } from '@envive-ai/react-toolkit-v3/ImageGallery';\nimport { PromptButtonVariant } from '@envive-ai/react-toolkit-v3/PromptButton';\nimport { PromptCarouselRows, AnimationSpeed } from '@envive-ai/react-toolkit-v3/PromptCarousel';\nimport { WidgetWrapperVariant } from '@envive-ai/react-toolkit-v3/WidgetWrapper';\nimport { ConfigVersionEnum, SocialProofWidgetKind, WidgetTypeV3 } from '../typesV3';\n\nconst mockImages = [\n  {\n    src: 'https://picsum.photos/400/600',\n    alt: 'Image 1',\n  },\n  {\n    src: 'https://picsum.photos/400/600',\n    alt: 'Image 2',\n  },\n  {\n    src: 'https://picsum.photos/400/600',\n    alt: 'Image 3',\n  },\n  {\n    src: 'https://picsum.photos/400/600',\n    alt: 'Image 4',\n  },\n];\n\nexport const mockV3ColorsConfig: CamelCasedPropertiesDeep<ColorMappingV3> = {\n  textPrimary: '#021414',\n  textSecondary: '#666666',\n  textAccent: '#478D87',\n  textLink: '#042E2C',\n  textLight: '#FFFFFF',\n  backgroundPrimary: '#1F5F51',\n  backgroundSecondary: '#F9F6EA',\n  backgroundTertiary: '#EEECDD',\n  backgroundDark: '#021414',\n  backgroundLight: '#FFFFFF',\n  borderLight: '#E6E7E7',\n  borderMedium: '#B3B8B8',\n  borderDark: '#021414',\n  accentPrimary: '#1F5F51',\n  accentSecondary: '#AE8659',\n};\n\nexport const mockV3FrontendConfig: FrontendConfigV3 = {\n  uiConfigs: {\n    version: ConfigVersionEnum.V3,\n    shortName: 'Envive AI',\n    lookAndFeel: {\n      theme: 'standard',\n      agentName: 'Envive AI',\n      chatHeaderLogoSrc: 'https://cdn.spiffy.ai/other/assets/envive-ai/Envive_Logo_Lt.svg',\n      widgetLogoSrc: 'https://cdn.spiffy.ai/other/assets/envive-ai/Envive_Logo_DK.svg',\n      hideWidgetLogo: false,\n      elementRadius: 8,\n      imageAspectRatio: '3/4',\n      buttonColors: {\n        lightButtonBackgroundColor: colorVar(ColorNames.BackgroundSecondary),\n        lightButtonIconColor: colorVar(ColorNames.AccentPrimary),\n        darkButtonBackgroundColor: colorVar(ColorNames.BackgroundDark),\n        darkButtonIconColor: colorVar(ColorNames.AccentPrimary),\n      },\n      typography: {\n        titleFontFamily: 'Poppins',\n        headerFontFamily: 'Poppins',\n        bodyFontFamily: 'Inter Variable',\n        fontSize: {\n          t1: '32px',\n          t2: '28px',\n          t3: '24px',\n          h1: '20px',\n          h2: '16px',\n          h3: '14px',\n          b1: '20px',\n          b2: '16px',\n          b3: '14px',\n          b4: '12px',\n          b5: '10px',\n          l1: '14px',\n          l2: '12px',\n        },\n        fontWeight: {\n          rg: '400',\n          md: '500',\n          sb: '600',\n        },\n        letterSpacing: {\n          '0': '0em',\n          'wide-1': '1px',\n        },\n        lineHeight: {\n          '124': 1.24,\n          '120': 1.2,\n          '118': 1.18,\n          '116': 1.16,\n          '114': 1.14,\n          '148': 1.48,\n          '140': 1.4,\n          '128': 1.28,\n          '130': 1.3,\n          '133': 1.33,\n        },\n      },\n    },\n    floatingButton: {\n      position: 'bottom-right',\n      backgroundColor: colorVar(ColorNames.BackgroundPrimary),\n      mode: 'light',\n      showOption: 'always',\n      style: 'attached',\n      iconSVGSrc: '',\n    },\n    floatingChat: {\n      headerBackgroundColor: colorVar(ColorNames.BackgroundPrimary),\n      headerMode: 'dark',\n      welcomeMessageIconColor: colorVar(ColorNames.AccentPrimary),\n      showVerifiedBuyer: false,\n      userCanEditQueries: true,\n      showEnviveLogo: true,\n      ignoreFirstModelResponse: false,\n      neverShowSingleProductCards: false,\n    },\n  },\n  pageVariants: [],\n  mountingConfigs: {},\n  widgetConfigs: {\n    'prompt-carousel-test-light-widget': {\n      widgetConfigId: 'prompt-carousel-test-light-widget',\n      contentId: 'prompt-carousel-test-light-widget',\n      type: WidgetTypeV3.PromptCarouselV3,\n\n      promptButtonType: PromptButtonVariant.LIGHT,\n      boldFirstButton: false,\n      promptCarouselRows: PromptCarouselRows.ALWAYS_ONE,\n      animationSpeed: AnimationSpeed.FAST,\n    },\n    'prompt-carousel-test-dark-widget': {\n      widgetConfigId: 'prompt-carousel-test-dark-widget',\n      contentId: 'prompt-carousel-test-dark-widget',\n      type: WidgetTypeV3.PromptCarouselV3,\n\n      promptButtonType: PromptButtonVariant.DARK,\n      boldFirstButton: false,\n      promptCarouselRows: PromptCarouselRows.ALWAYS_ONE,\n      animationSpeed: AnimationSpeed.FAST,\n    },\n    'titled-prompt-carousel-test-light-widget': {\n      widgetConfigId: 'titled-prompt-carousel-test-light-widget',\n      contentId: 'titled-prompt-carousel-test-light-widget',\n      type: WidgetTypeV3.TitledPromptCarouselV3,\n\n      promptButtonType: PromptButtonVariant.LIGHT,\n      boldFirstButton: false,\n      promptCarouselRows: PromptCarouselRows.ALWAYS_ONE,\n      animationSpeed: AnimationSpeed.FAST,\n    },\n    'titled-prompt-carousel-test-dark-widget': {\n      widgetConfigId: 'titled-prompt-carousel-test-dark-widget',\n      contentId: 'titled-prompt-carousel-test-dark-widget',\n      type: WidgetTypeV3.TitledPromptCarouselV3,\n\n      promptButtonType: PromptButtonVariant.DARK,\n      boldFirstButton: false,\n      promptCarouselRows: PromptCarouselRows.ALWAYS_ONE,\n      animationSpeed: AnimationSpeed.FAST,\n    },\n    'social-proof-test-widget-four-grid': {\n      widgetConfigId: 'social-proof-test-widget-four-grid',\n      contentId: 'social-proof-test-widget-four-grid',\n      type: WidgetTypeV3.SocialProofV3,\n\n      imageGalleryLayout: ImageGalleryLayout.FOUR_GRID,\n      kind: SocialProofWidgetKind.STATIC,\n      variant: WidgetWrapperVariant.INLINE_WITH_BORDER,\n      promptCarouselRows: PromptCarouselRows.TWO_ON_MOBILE_ONE_ON_DESKTOP,\n      primaryButtonVariant: PromptButtonVariant.DARK,\n      secondaryButtonVariant: PromptButtonVariant.LIGHT,\n      images: mockImages,\n    },\n    'social-proof-test-widget-single': {\n      widgetConfigId: 'social-proof-test-widget-single',\n      contentId: 'social-proof-test-widget-single',\n      type: WidgetTypeV3.SocialProofV3,\n\n      imageGalleryLayout: ImageGalleryLayout.SINGLE,\n      kind: SocialProofWidgetKind.STATIC,\n      variant: WidgetWrapperVariant.CARD_NO_BORDER,\n      promptCarouselRows: PromptCarouselRows.TWO_ON_MOBILE_ONE_ON_DESKTOP,\n      primaryButtonVariant: PromptButtonVariant.DARK,\n      secondaryButtonVariant: PromptButtonVariant.LIGHT,\n      images: mockImages,\n    },\n    'social-proof-test-widget-four-horizontal': {\n      widgetConfigId: 'social-proof-test-widget-four-horizontal',\n      contentId: 'social-proof-test-widget-four-horizontal',\n      type: WidgetTypeV3.SocialProofV3,\n\n      imageGalleryLayout: ImageGalleryLayout.FOUR_HORIZONTAL,\n      kind: SocialProofWidgetKind.STATIC,\n      variant: WidgetWrapperVariant.CARD_WITH_BORDER,\n      promptCarouselRows: PromptCarouselRows.TWO_ON_MOBILE_ONE_ON_DESKTOP,\n      primaryButtonVariant: PromptButtonVariant.DARK,\n      secondaryButtonVariant: PromptButtonVariant.LIGHT,\n      images: mockImages,\n    },\n  },\n};\n"],"mappings":"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"}

package/dist/contexts/hardcopyContext/hardcopyContext.cjs

@@ -0,0 +1,169 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_contexts_typesV3 = require('../typesV3.cjs');
+const require_logger = require('../../application/logging/logger.cjs');
+const require_snakeToCamelTransformer = require('../../application/models/utils/snakeToCamelTransformer.cjs');
+const require_atoms_app_index = require('../../atoms/app/index.cjs');
+const require_featureFlagServiceContext = require('../featureFlagServiceContext/featureFlagServiceContext.cjs');
+const require_commerce_api = require('../../application/commerce-api.cjs');
+let react = require("react");
+let jotai = require("jotai");
+let react_jsx_runtime = require("react/jsx-runtime");
+
+//#region src/contexts/hardcopyContext/hardcopyContext.tsx
+const convertToHardcopyResponse = (response) => {
+	return {
+		language: response.language,
+		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)]))
+	};
+};
+const MOCK_HARDCOPY_RESPONSE = {
+	[require_contexts_typesV3.WidgetTypeV3.PromptCarouselV3]: {
+		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]: {
+		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.TypingAnimationV3]: {
+		language: "en",
+		values: {
+			chatPreviewTitle: "Chat Preview Title",
+			typewriterTextPrefix: "Want to know",
+			typewriterTexts: [
+				"more about this product?",
+				"what others are saying?",
+				"how to use it?"
+			],
+			suggestionButtons: [
+				"Button 1",
+				"Button 2",
+				"Button 3"
+			],
+			footerText: "Ask me anything...",
+			chatPreviewDescription: "Chat Preview Description"
+		}
+	},
+	[require_contexts_typesV3.WidgetTypeV3.SocialProofV3]: {
+		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.ChatPreviewComparisonV3]: {
+		language: "en",
+		values: {
+			titleLabel: "Shopping Assistant",
+			headlineText: "Need help comparing?",
+			textFieldPlaceholderText: "Ask me anything..."
+		}
+	},
+	[require_contexts_typesV3.WidgetTypeV3.ChatPreviewLoadingV3]: {
+		language: "en",
+		values: {
+			titleLabel: "Shopping Assistant",
+			textFieldPlaceholderText: "Ask me anything..."
+		}
+	},
+	[require_contexts_typesV3.WidgetTypeV3.ChatPreviewV3]: {
+		language: "en",
+		values: {
+			titleLabel: "Shopping Assistant",
+			textFieldPlaceholderText: "Ask me anything..."
+		}
+	}
+};
+const HardcopyContext = (0, react.createContext)(void 0);
+const HardcopyProvider = ({ children }) => {
+	const languages = (0, react.useMemo)(() => navigator.languages, []);
+	const [isLoading, setIsLoading] = (0, react.useState)(false);
+	const context = (0, jotai.useAtomValue)(require_atoms_app_index.appDetailsAtom);
+	const { featureFlagService } = require_featureFlagServiceContext.useFeatureFlagService();
+	const getHardcopyFromBackend = (0, react.useCallback)(async (request) => {
+		const widgetTextRequest = {
+			widgetType: request.widgetType,
+			context,
+			featureFlags: featureFlagService?.getFeatureFlags() || {},
+			language: languages[0] || "en",
+			url: window.location.href
+		};
+		try {
+			const response = await require_commerce_api.default.getHardcopy(widgetTextRequest);
+			if (response) {
+				const convertedResponse = convertToHardcopyResponse(response);
+				require_logger.default.logInfo("hardcopyContext | converted response", convertedResponse);
+				return convertedResponse;
+			}
+		} catch (error) {
+			require_logger.default.logError("hardcopyContext | error getting hardcopy from backend", error);
+		}
+		const mockResponse = MOCK_HARDCOPY_RESPONSE[request.widgetType];
+		if (mockResponse) {
+			require_logger.default.logInfo("hardcopyContext | no real response, using mock", mockResponse);
+			return mockResponse;
+		}
+		throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);
+	}, [
+		context,
+		featureFlagService,
+		languages
+	]);
+	const getHardcopy = (0, react.useCallback)(async (request) => {
+		setIsLoading(true);
+		require_logger.default.logInfo("hardcopyContext | retrieving hardcopy", languages);
+		require_logger.default.logInfo("hardcopyContext | request", request);
+		const response = await getHardcopyFromBackend(request);
+		require_logger.default.logInfo("hardcopyContext | returning hardcopy response", response);
+		if (!response) {
+			setIsLoading(false);
+			throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);
+		}
+		setIsLoading(false);
+		return response;
+	}, [getHardcopyFromBackend, languages]);
+	const value = (0, react.useMemo)(() => ({
+		getHardcopy,
+		isLoading
+	}), [getHardcopy, isLoading]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(HardcopyContext.Provider, {
+		value,
+		children
+	});
+};
+const useHardcopy = () => {
+	const context = (0, react.useContext)(HardcopyContext);
+	if (!context) throw new Error("useHardcopy must be used within a HardcopyProvider");
+	return context;
+};
+
+//#endregion
+exports.HardcopyProvider = HardcopyProvider;
+exports.useHardcopy = useHardcopy;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"hardcopyContext.cjs","names":["toCamelCase","MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>>","WidgetTypeV3","HardcopyProvider: React.FC<{ children: ReactNode }>","appDetailsAtom","useFeatureFlagService","widgetTextRequest: WidgetTextRequest","CommerceApiClient"],"sources":["../../../src/contexts/hardcopyContext/hardcopyContext.tsx"],"sourcesContent":["import { UserEvent } from '@spiffy-ai/commerce-api-client';\nimport { ReactNode, createContext, useCallback, useContext, useMemo, useState } from 'react';\nimport Logger from 'src/application/logging/logger';\n\nimport CommerceApiClient from 'src/application/commerce-api';\nimport { WidgetText } from 'src/application/models/api/widgetText';\nimport { WidgetTextRequest } from 'src/application/models/api/widgetTextRequest';\n\nimport { useAtomValue } from 'jotai';\nimport { appDetailsAtom } from 'src/atoms/app';\nimport { toCamelCase } from 'src/application/models/utils/snakeToCamelTransformer';\nimport { WidgetTypeV3 } from '../typesV3';\nimport { useFeatureFlagService } from '../featureFlagServiceContext/featureFlagServiceContext';\n\ninterface HardcopyRequest {\n  widgetType: WidgetTypeV3;\n  userEvent: UserEvent;\n}\n\nexport type HardcopyResponse = {\n  language: string;\n  values: Record<string, string | string[]>;\n};\n\ninterface HardcopyContextType {\n  getHardcopy: (HardcopyRequest: HardcopyRequest) => Promise<HardcopyResponse>;\n  isLoading: boolean;\n}\n\nconst convertToHardcopyResponse = (response: WidgetText): HardcopyResponse => {\n  return {\n    language: response.language,\n    values: Object.fromEntries(\n      Object.entries(response.values).map(([key, value]) => [\n        // Transform the key from snake_case to camelCase\n        toCamelCase(key),\n        value.length === 1 ? value[0].value : value.map(v => v.value),\n      ]),\n    ),\n  };\n};\n\n// These are just sample responses for the sake of testing.\n// As we start to build the actual widgets we should determine what the actual\n// values and their names should be.\nconst MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {\n  [WidgetTypeV3.PromptCarouselV3]: {\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    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.TypingAnimationV3]: {\n    language: 'en',\n    values: {\n      chatPreviewTitle: 'Chat Preview Title',\n      typewriterTextPrefix: 'Want to know',\n      typewriterTexts: ['more about this product?', 'what others are saying?', 'how to use it?'],\n      suggestionButtons: ['Button 1', 'Button 2', 'Button 3'],\n      footerText: 'Ask me anything...',\n\n      chatPreviewDescription: 'Chat Preview Description',\n    },\n  },\n  [WidgetTypeV3.SocialProofV3]: {\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.ChatPreviewComparisonV3]: {\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    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewV3]: {\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n};\n\nconst HardcopyContext = createContext<HardcopyContextType | undefined>(undefined);\n\nexport const HardcopyProvider: React.FC<{ children: ReactNode }> = ({ children }) => {\n  const languages = useMemo(() => navigator.languages, []);\n  const [isLoading, setIsLoading] = useState(false);\n  const context = useAtomValue(appDetailsAtom);\n\n  const { featureFlagService } = useFeatureFlagService();\n  const getHardcopyFromBackend = useCallback(\n    async (request: HardcopyRequest): Promise<HardcopyResponse> => {\n      const widgetTextRequest: WidgetTextRequest = {\n        widgetType: request.widgetType,\n        context,\n        featureFlags: featureFlagService?.getFeatureFlags() || {},\n        language: languages[0] || 'en',\n        url: window.location.href,\n      };\n      try {\n        const response = await CommerceApiClient.getHardcopy(widgetTextRequest);\n        if (response) {\n          const convertedResponse = convertToHardcopyResponse(response);\n          Logger.logInfo('hardcopyContext | converted response', convertedResponse);\n          return convertedResponse;\n        }\n      } catch (error) {\n        Logger.logError('hardcopyContext | error getting hardcopy from backend', error);\n      }\n      const mockResponse = MOCK_HARDCOPY_RESPONSE[request.widgetType];\n      if (mockResponse) {\n        Logger.logInfo('hardcopyContext | 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    [context, featureFlagService, languages],\n  );\n\n  const getHardcopy = useCallback(\n    async (request: HardcopyRequest): Promise<HardcopyResponse> => {\n      setIsLoading(true);\n      Logger.logInfo('hardcopyContext | retrieving hardcopy', languages);\n\n      Logger.logInfo('hardcopyContext | request', request);\n      const response = await getHardcopyFromBackend(request);\n      Logger.logInfo('hardcopyContext | returning hardcopy response', response);\n      if (!response) {\n        setIsLoading(false);\n        throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n      }\n      setIsLoading(false);\n      return response;\n    },\n    [getHardcopyFromBackend, languages],\n  );\n\n  const value = useMemo(() => ({ getHardcopy, isLoading }), [getHardcopy, isLoading]);\n\n  return <HardcopyContext.Provider value={value}>{children}</HardcopyContext.Provider>;\n};\n\nexport const useHardcopy = () => {\n  const context = useContext(HardcopyContext);\n  if (!context) {\n    throw new Error('useHardcopy must be used within a HardcopyProvider');\n  }\n  return context;\n};\n"],"mappings":"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"}

package/dist/contexts/hardcopyContext/hardcopyContext.d.cts

@@ -0,0 +1,24 @@
+import { WidgetTypeV3 } from "../typesV3.cjs";
+import { UserEvent } from "@spiffy-ai/commerce-api-client";
+import { ReactNode } from "react";
+
+//#region src/contexts/hardcopyContext/hardcopyContext.d.ts
+interface HardcopyRequest {
+  widgetType: WidgetTypeV3;
+  userEvent: UserEvent;
+}
+type HardcopyResponse = {
+  language: string;
+  values: Record<string, string | string[]>;
+};
+interface HardcopyContextType {
+  getHardcopy: (HardcopyRequest: HardcopyRequest) => Promise<HardcopyResponse>;
+  isLoading: boolean;
+}
+declare const HardcopyProvider: React.FC<{
+  children: ReactNode;
+}>;
+declare const useHardcopy: () => HardcopyContextType;
+//#endregion
+export { HardcopyProvider, HardcopyResponse, useHardcopy };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFyZGNvcHlDb250ZXh0LmQuY3RzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb250ZXh0cy9oYXJkY29weUNvbnRleHQvaGFyZGNvcHlDb250ZXh0LmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVXNlckV2ZW50IH0gZnJvbSAnQHNwaWZmeS1haS9jb21tZXJjZS1hcGktY2xpZW50JztcbmltcG9ydCB7IFJlYWN0Tm9kZSB9IGZyb20gJ3JlYWN0JztcbmltcG9ydCB7IFdpZGdldFR5cGVWMyB9IGZyb20gJy4uL3R5cGVzVjMnO1xuaW50ZXJmYWNlIEhhcmRjb3B5UmVxdWVzdCB7XG4gICAgd2lkZ2V0VHlwZTogV2lkZ2V0VHlwZVYzO1xuICAgIHVzZXJFdmVudDogVXNlckV2ZW50O1xufVxuZXhwb3J0IHR5cGUgSGFyZGNvcHlSZXNwb25zZSA9IHtcbiAgICBsYW5ndWFnZTogc3RyaW5nO1xuICAgIHZhbHVlczogUmVjb3JkPHN0cmluZywgc3RyaW5nIHwgc3RyaW5nW10+O1xufTtcbmludGVyZmFjZSBIYXJkY29weUNvbnRleHRUeXBlIHtcbiAgICBnZXRIYXJkY29weTogKEhhcmRjb3B5UmVxdWVzdDogSGFyZGNvcHlSZXF1ZXN0KSA9PiBQcm9taXNlPEhhcmRjb3B5UmVzcG9uc2U+O1xuICAgIGlzTG9hZGluZzogYm9vbGVhbjtcbn1cbmV4cG9ydCBkZWNsYXJlIGNvbnN0IEhhcmRjb3B5UHJvdmlkZXI6IFJlYWN0LkZDPHtcbiAgICBjaGlsZHJlbjogUmVhY3ROb2RlO1xufT47XG5leHBvcnQgZGVjbGFyZSBjb25zdCB1c2VIYXJkY29weTogKCkgPT4gSGFyZGNvcHlDb250ZXh0VHlwZTtcbmV4cG9ydCB7fTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFHQSxJQUFJLGtCQUFrQjtDQUFDO09BQUc7T0FBQTtDQUFBO0FBQzFCLElBQVcsbUJBQWlCLENBQUEsV0FBQSxPQUFBO0FBQzVCLElBQUksc0JBQW9CO0NBQUE7T0FBQTtPQUFBO09BQUE7Q0FBQTtBQUN4QixJQUFBLG1CQUFBO0NBQUE7T0FBQTtPQUFBLE1BQUE7Q0FBQTtBQUNBLElBQVcsY0FBYyxDQUFDLFdBQUssb0JBQUEifQ==

package/dist/contexts/hardcopyContext/hardcopyContext.d.ts

@@ -0,0 +1,24 @@
+import { WidgetTypeV3 } from "../typesV3.js";
+import { UserEvent } from "@spiffy-ai/commerce-api-client";
+import { ReactNode } from "react";
+
+//#region src/contexts/hardcopyContext/hardcopyContext.d.ts
+interface HardcopyRequest {
+  widgetType: WidgetTypeV3;
+  userEvent: UserEvent;
+}
+type HardcopyResponse = {
+  language: string;
+  values: Record<string, string | string[]>;
+};
+interface HardcopyContextType {
+  getHardcopy: (HardcopyRequest: HardcopyRequest) => Promise<HardcopyResponse>;
+  isLoading: boolean;
+}
+declare const HardcopyProvider: React.FC<{
+  children: ReactNode;
+}>;
+declare const useHardcopy: () => HardcopyContextType;
+//#endregion
+export { HardcopyProvider, HardcopyResponse, useHardcopy };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFyZGNvcHlDb250ZXh0LmQudHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbnRleHRzL2hhcmRjb3B5Q29udGV4dC9oYXJkY29weUNvbnRleHQuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBVc2VyRXZlbnQgfSBmcm9tICdAc3BpZmZ5LWFpL2NvbW1lcmNlLWFwaS1jbGllbnQnO1xuaW1wb3J0IHsgUmVhY3ROb2RlIH0gZnJvbSAncmVhY3QnO1xuaW1wb3J0IHsgV2lkZ2V0VHlwZVYzIH0gZnJvbSAnLi4vdHlwZXNWMyc7XG5pbnRlcmZhY2UgSGFyZGNvcHlSZXF1ZXN0IHtcbiAgICB3aWRnZXRUeXBlOiBXaWRnZXRUeXBlVjM7XG4gICAgdXNlckV2ZW50OiBVc2VyRXZlbnQ7XG59XG5leHBvcnQgdHlwZSBIYXJkY29weVJlc3BvbnNlID0ge1xuICAgIGxhbmd1YWdlOiBzdHJpbmc7XG4gICAgdmFsdWVzOiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmcgfCBzdHJpbmdbXT47XG59O1xuaW50ZXJmYWNlIEhhcmRjb3B5Q29udGV4dFR5cGUge1xuICAgIGdldEhhcmRjb3B5OiAoSGFyZGNvcHlSZXF1ZXN0OiBIYXJkY29weVJlcXVlc3QpID0+IFByb21pc2U8SGFyZGNvcHlSZXNwb25zZT47XG4gICAgaXNMb2FkaW5nOiBib29sZWFuO1xufVxuZXhwb3J0IGRlY2xhcmUgY29uc3QgSGFyZGNvcHlQcm92aWRlcjogUmVhY3QuRkM8e1xuICAgIGNoaWxkcmVuOiBSZWFjdE5vZGU7XG59PjtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IHVzZUhhcmRjb3B5OiAoKSA9PiBIYXJkY29weUNvbnRleHRUeXBlO1xuZXhwb3J0IHt9O1xuIl0sIm1hcHBpbmdzIjoiOzs7OztBQUdBLElBQUksa0JBQWtCO0NBQUM7T0FBRztPQUFBO0NBQUE7QUFDMUIsSUFBVyxtQkFBaUIsQ0FBQSxXQUFBLE9BQUE7QUFDNUIsSUFBSSxzQkFBb0I7Q0FBQTtPQUFBO09BQUE7T0FBQTtDQUFBO0FBQ3hCLElBQUEsbUJBQUE7Q0FBQTtPQUFBO09BQUEsTUFBQTtDQUFBO0FBQ0EsSUFBVyxjQUFjLENBQUMsV0FBSyxvQkFBQSJ9