@envive-ai/react-hooks 0.3.3 → 0.3.5

package/dist/contexts/graphqlContext/graphqlContext.cjs

@@ -1,11 +1,15 @@
 const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
-const require_logger = require('../../application/logging/logger.cjs');
+const require_contexts_types = require('../types.cjs');
+const require_contexts_typesV3 = require('../typesV3.cjs');
 const require_config_versions = require('../../types/config-versions.cjs');
 const require_getMerchantOrgIdQuery = require('../../application/models/graphql/queries/getMerchantOrgIdQuery.cjs');
+const require_logger = require('../../application/logging/logger.cjs');
 const require_snakeToCamelTransformer = require('../../application/models/utils/snakeToCamelTransformer.cjs');
+const require_validateGraphQLFrontendConfig = require('../../application/models/validators/validateGraphQLFrontendConfig.cjs');
 const require_validateGraphQLOrgId = require('../../application/models/validators/validateGraphQLOrgId.cjs');
 require('../../application/models/index.cjs');
 const require_enviveConfig = require('../../atoms/envive/enviveConfig.cjs');
+const require_mockV3Config = require('./mockV3Config.cjs');
 let react = require("react");
 react = require_rolldown_runtime.__toESM(react);
 let jotai = require("jotai");
@@ -19,14 +23,91 @@ const colorsAndFrontendConfigQuery = () => `
       getProductsConfigByVersion(version: $version) {
         frontend { values }
         colors { values }
+        v_three_config { values }
       }
     }
   }
 `;
-const GraphQLProvider = ({ children }) => {
+const DEFAULT_PAGE_VARIANTS = [{
+	variantId: "plp",
+	variantType: "plp",
+	plpIdExtractor: "url-resolver-plp-id",
+	widgetMounting: [],
+	variantTests: [{ testType: require_contexts_types.PageVariantTestType.UrlResolver }]
+}, {
+	variantId: "pdp",
+	variantType: "pdp",
+	productIdExtractor: "url-resolver-product-id",
+	widgetMounting: [],
+	variantTests: [{ testType: require_contexts_types.PageVariantTestType.UrlResolver }]
+}];
+const mapPositionToCamelCase = (position) => {
+	if (position === "bottom-left") return "bottomLeft";
+	if (position === "middle-left") return "middleLeft";
+	if (position === "middle-right") return "middleRight";
+	if (position === "bottom-right") return "bottomRight";
+	throw new Error(`Invalid position: ${position}`);
+};
+/**
+* This function is used to do some additional cleanup of the v3 frontend config to ensure that the config is in the correct format.
+*/
+const v3FrontendConfigCleanup = (v3RootConfig) => {
+	const { uiConfigs } = v3RootConfig;
+	if (!uiConfigs) return v3RootConfig;
+	const { floatingButton, lookAndFeel } = uiConfigs;
+	if (!floatingButton || !lookAndFeel) return v3RootConfig;
+	const { fontSize, lineHeight } = lookAndFeel.typography;
+	return {
+		...v3RootConfig,
+		uiConfigs: {
+			...uiConfigs,
+			floatingButton: {
+				...floatingButton,
+				position: mapPositionToCamelCase(v3RootConfig.uiConfigs?.floatingButton?.position)
+			},
+			lookAndFeel: {
+				...lookAndFeel,
+				chatHeaderLogoDarkSrc: lookAndFeel.chatHeaderLogoDarkSrc || lookAndFeel.chatHeaderLogoSrc,
+				chatHeaderLogoLightSrc: lookAndFeel.chatHeaderLogoLightSrc || lookAndFeel.chatHeaderLogoSrc,
+				typography: {
+					...lookAndFeel.typography,
+					fontSize: {
+						b1: fontSize?.b1 || fontSize?.b_1,
+						b2: fontSize?.b2 || fontSize?.b_2,
+						b3: fontSize?.b3 || fontSize?.b_3,
+						b4: fontSize?.b4 || fontSize?.b_4,
+						b5: fontSize?.b5 || fontSize?.b_5,
+						h1: fontSize?.h1 || fontSize?.h_1,
+						h2: fontSize?.h2 || fontSize?.h_2,
+						h3: fontSize?.h3 || fontSize?.h_3,
+						l1: fontSize?.l1 || fontSize?.l_1,
+						l2: fontSize?.l2 || fontSize?.l_2,
+						t1: fontSize?.t1 || fontSize?.t_1,
+						t2: fontSize?.t2 || fontSize?.t_2,
+						t3: fontSize?.t3 || fontSize?.t_3
+					},
+					lineHeight: {
+						...lookAndFeel.typography.lineHeight,
+						"114": lineHeight?.lh_114 || lineHeight?.[114],
+						"116": lineHeight?.lh_116 || lineHeight?.[116],
+						"118": lineHeight?.lh_118 || lineHeight?.[118],
+						"120": lineHeight?.lh_120 || lineHeight?.[120],
+						"124": lineHeight?.lh_124 || lineHeight?.[124],
+						"128": lineHeight?.lh_128 || lineHeight?.[128],
+						"130": lineHeight?.lh_130 || lineHeight?.[130],
+						"133": lineHeight?.lh_133 || lineHeight?.[133],
+						"140": lineHeight?.lh_140 || lineHeight?.[140],
+						"148": lineHeight?.lh_148 || lineHeight?.[148]
+					}
+				}
+			}
+		}
+	};
+};
+const GraphQLProvider = ({ children, requestV3Config = false, mockV3ConfigToDeprecatedConfig = false }) => {
 	const apiKey = (0, jotai.useAtomValue)(require_enviveConfig.orgLevelApiKeyAtom);
 	const baseUrl = (0, jotai.useAtomValue)(require_enviveConfig.baseUrlAtom);
-	const isReady = Boolean(apiKey && baseUrl);
+	const isReady = (0, react.useMemo)(() => Boolean(apiKey && baseUrl), [apiKey, baseUrl]);
 	const executeQuery = (0, react.useCallback)(async (query, variables) => {
 		if (!isReady) throw new Error("GraphQL client not ready - missing apiKey or baseUrl");
 		const response = await fetch(`${baseUrl}/v1/graphql`, {
@@ -52,16 +133,65 @@ const GraphQLProvider = ({ children }) => {
 	const getOrgId = (0, react.useCallback)(async () => {
 		return require_validateGraphQLOrgId.validateGraphQLOrgId((await executeQuery(require_getMerchantOrgIdQuery.getMerchantOrgIdQuery)).me.org?.id);
 	}, [executeQuery]);
+	const getV3Config = (0, react.useCallback)(async () => {
+		try {
+			const query = await colorsAndFrontendConfigQuery();
+			if (!query) throw new Error("Colors and frontend config query is not defined");
+			const v3RootConfig = (await executeQuery(query)).me.getProductsConfigByVersion?.v_three_config?.values;
+			const v3FrontendConfig = v3FrontendConfigCleanup(require_snakeToCamelTransformer.transformSnakeToCamel(v3RootConfig));
+			const v3MountingConfigs = (require_snakeToCamelTransformer.transformSnakeToCamel(v3RootConfig?.mounting_configs) ?? []).reduce((acc, { key, config }) => {
+				acc[key] = require_validateGraphQLFrontendConfig.validateAndTransformMountingConfig(config, key);
+				return acc;
+			}, {});
+			const v3widgetConfigsArray = require_snakeToCamelTransformer.transformSnakeToCamel(v3RootConfig?.widget_configs) ?? [];
+			const v3WidgetConfigs = Object.fromEntries(v3widgetConfigsArray?.map(({ widgetConfigId, ...rest }) => [widgetConfigId, {
+				widgetConfigId,
+				...rest
+			}]));
+			const v3pageVariants = Array.isArray(v3RootConfig?.page_variants) ? v3RootConfig?.page_variants.map(require_validateGraphQLFrontendConfig.validateAndTransformPageVariants) : DEFAULT_PAGE_VARIANTS;
+			const v3ColorsConfig = require_snakeToCamelTransformer.transformSnakeToCamel(v3RootConfig?.colors?.values);
+			if (!v3RootConfig && mockV3ConfigToDeprecatedConfig) return {
+				colorsConfig: !window.location.href.includes("globals=merchant") ? require_mockV3Config.mockV3ColorsConfig : v3ColorsConfig,
+				frontendConfig: require_mockV3Config.mockV3FrontendConfig
+			};
+			return {
+				colorsConfig: v3ColorsConfig,
+				frontendConfig: {
+					...v3FrontendConfig,
+					widgetConfigs: v3WidgetConfigs
+				},
+				orgPageConfig: {
+					pageVariants: v3pageVariants,
+					widgetConfigs: v3WidgetConfigs,
+					mountingConfigs: v3MountingConfigs
+				}
+			};
+		} catch (err) {
+			require_logger.default.logError("Error fetching graphql colors and frontend config", err);
+			return {
+				colorsConfig: void 0,
+				frontendConfig: void 0
+			};
+		}
+	}, [executeQuery, mockV3ConfigToDeprecatedConfig]);
 	const getColorsAndFrontendConfig = (0, react.useCallback)(async () => {
 		try {
 			const query = await colorsAndFrontendConfigQuery();
 			if (!query) throw new Error("Colors and frontend config query is not defined");
 			const response = await executeQuery(query);
-			const colorsConfig = response.me.getProductsConfigByVersion?.colors?.values;
-			const frontendConfig = response.me.getProductsConfigByVersion?.frontend?.values;
+			if (response.me.getProductsConfigByVersion?.version !== require_contexts_typesV3.ConfigVersionEnum.V3 && !mockV3ConfigToDeprecatedConfig) {
+				const colorsConfig = response.me.getProductsConfigByVersion?.colors?.values;
+				const frontendConfig = response.me.getProductsConfigByVersion?.frontend?.values;
+				return {
+					colorsConfig: require_snakeToCamelTransformer.transformSnakeToCamel(colorsConfig),
+					frontendConfig: require_snakeToCamelTransformer.transformSnakeToCamel(frontendConfig)
+				};
+			}
+			const merchantColorsConfig = response.me.getProductsConfigByVersion?.colors?.values;
+			const transformedMerchantColorConfig = require_snakeToCamelTransformer.transformSnakeToCamel(merchantColorsConfig);
 			return {
-				colorsConfig: require_snakeToCamelTransformer.transformSnakeToCamel(colorsConfig),
-				frontendConfig: require_snakeToCamelTransformer.transformSnakeToCamel(frontendConfig)
+				colorsConfig: !window.location.href.includes("globals=merchant") ? require_mockV3Config.mockV3ColorsConfig : transformedMerchantColorConfig,
+				frontendConfig: require_mockV3Config.mockV3FrontendConfig
 			};
 		} catch (err) {
 			require_logger.default.logError("Error fetching graphql colors and frontend config", err);
@@ -71,15 +201,28 @@ const GraphQLProvider = ({ children }) => {
 			};
 		}
 	}, [executeQuery]);
+	const getConfig = (0, react.useCallback)(async () => {
+		console.log("GraphQLProvider: getConfig: requestV3Config", requestV3Config);
+		if (requestV3Config) return getV3Config();
+		return getColorsAndFrontendConfig();
+	}, [
+		getColorsAndFrontendConfig,
+		getV3Config,
+		requestV3Config
+	]);
 	const value = (0, react.useMemo)(() => ({
 		executeQuery,
 		getOrgId,
 		getColorsAndFrontendConfig,
+		getV3Config,
+		getConfig,
 		isReady
 	}), [
 		executeQuery,
 		getOrgId,
 		getColorsAndFrontendConfig,
+		getV3Config,
+		getConfig,
 		isReady
 	]);
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(GraphQLContext.Provider, {
@@ -96,4 +239,4 @@ const useGraphQLClient = () => {
 //#endregion
 exports.GraphQLProvider = GraphQLProvider;
 exports.useGraphQLClient = useGraphQLClient;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"graphqlContext.cjs","names":["configVersion","orgLevelApiKeyAtom","baseUrlAtom","validateGraphQLOrgId","getMerchantOrgIdQuery","transformSnakeToCamel"],"sources":["../../../src/contexts/graphqlContext/graphqlContext.tsx"],"sourcesContent":["import React, { ReactNode, createContext, useCallback, useContext, useMemo } from 'react';\nimport { useAtomValue } from 'jotai';\nimport { baseUrlAtom, orgLevelApiKeyAtom } from 'src/atoms/envive/enviveConfig';\nimport { getMerchantOrgIdQuery } from 'src/application/models/graphql/queries/getMerchantOrgIdQuery';\nimport { validateGraphQLOrgId } from 'src/application/models/validators/validateGraphQLOrgId';\nimport {\n  GetMerchantColorsQueryData,\n  GetMerchantFrontendConfigQueryData,\n} from 'src/application/models/graphql';\nimport { ColorMapping } from 'src/application/models/colorsConfig';\nimport { FrontendConfig } from 'src/application/models/frontendConfig';\nimport Logger from 'src/application/logging/logger';\nimport { configVersion } from 'src/types/config-versions';\nimport { CamelCasedPropertiesDeep, transformSnakeToCamel } from 'src/application/models';\n\ninterface BaseMeConfigQueryResponse {\n  me: {\n    org?: {\n      id: string;\n    };\n    getProductsConfigByVersion?: {\n      frontend?: {\n        values: CamelCasedPropertiesDeep<GetMerchantFrontendConfigQueryData>;\n      };\n      colors?: { values: CamelCasedPropertiesDeep<GetMerchantColorsQueryData> };\n    };\n  };\n}\nexport type ColorsConfigResponse = CamelCasedPropertiesDeep<ColorMapping>;\nexport type FrontendConfigResponse = CamelCasedPropertiesDeep<FrontendConfig>;\n\nexport type GraphQlConfigValues = {\n  colorsConfig?: ColorsConfigResponse;\n  frontendConfig?: CamelCasedPropertiesDeep<FrontendConfig>;\n};\n\ninterface GraphQLContextValue {\n  executeQuery: <T>(query: string, variables?: Record<string, unknown>) => Promise<T>;\n  getOrgId: () => Promise<string | undefined>;\n  getColorsAndFrontendConfig: () => Promise<GraphQlConfigValues>;\n  isReady: boolean;\n}\n\nconst GraphQLContext = createContext<GraphQLContextValue | null>(null);\n\nconst colorsAndFrontendConfigQuery = () => `\n  query ($version: String = \"${configVersion()}\") {\n    me {\n      getProductsConfigByVersion(version: $version) {\n        frontend { values }\n        colors { values }\n      }\n    }\n  }\n`;\n\ntype GraphQLProviderProps = {\n  children: ReactNode;\n};\n\nexport const GraphQLProvider = ({ children }: GraphQLProviderProps) => {\n  const apiKey = useAtomValue(orgLevelApiKeyAtom);\n  const baseUrl = useAtomValue(baseUrlAtom);\n\n  const isReady = Boolean(apiKey && baseUrl);\n\n  const executeQuery = useCallback(\n    async (query: string, variables?: Record<string, unknown>) => {\n      if (!isReady) {\n        throw new Error('GraphQL client not ready - missing apiKey or baseUrl');\n      }\n\n      const response = await fetch(`${baseUrl}/v1/graphql`, {\n        method: 'POST',\n        headers: {\n          'Content-Type': 'application/json',\n          Authorization: `Bearer ${apiKey}`,\n        },\n        body: JSON.stringify({ query, variables }),\n      });\n\n      if (!response.ok) {\n        throw new Error(`GraphQL request failed: ${response.statusText}`);\n      }\n\n      const result = await response.json();\n      if (result.errors) {\n        throw new Error(`GraphQL errors: ${JSON.stringify(result.errors)}`);\n      }\n\n      return result.data;\n    },\n    [apiKey, baseUrl, isReady],\n  );\n\n  const getOrgId = useCallback(async () => {\n    const response = await executeQuery(getMerchantOrgIdQuery);\n    return validateGraphQLOrgId(response.me.org?.id);\n  }, [executeQuery]);\n\n  const getColorsAndFrontendConfig = useCallback(async (): Promise<GraphQlConfigValues> => {\n    try {\n      const query = await colorsAndFrontendConfigQuery();\n      if (!query) {\n        throw new Error('Colors and frontend config query is not defined');\n      }\n      const response = await executeQuery(query);\n      const colorsConfig = response.me.getProductsConfigByVersion?.colors?.values;\n      const frontendConfig = response.me.getProductsConfigByVersion?.frontend?.values;\n      const transformedColorConfig = transformSnakeToCamel(colorsConfig);\n      const transformedFrontendConfig = transformSnakeToCamel(frontendConfig);\n      return {\n        colorsConfig: transformedColorConfig as ColorsConfigResponse,\n        frontendConfig: transformedFrontendConfig as FrontendConfigResponse,\n      };\n    } catch (err) {\n      Logger.logError('Error fetching graphql colors and frontend config', err);\n      return { colorsConfig: undefined, frontendConfig: undefined };\n    }\n  }, [executeQuery]);\n\n  const value = useMemo(\n    () => ({\n      executeQuery,\n      getOrgId,\n      getColorsAndFrontendConfig,\n      isReady,\n    }),\n    [executeQuery, getOrgId, getColorsAndFrontendConfig, isReady],\n  );\n\n  return <GraphQLContext.Provider value={value}>{children}</GraphQLContext.Provider>;\n};\n\nexport const useGraphQLClient = () => {\n  const context = useContext(GraphQLContext);\n  if (!context) {\n    throw new Error('useGraphQLClient must be used within a GraphQLProvider');\n  }\n  return context;\n};\n"],"mappings":";;;;;;;;;;;;;;AA2CA,MAAM,0CAA2D,KAAK;AAEtE,MAAM,qCAAqC;+BACZA,uCAAe,CAAC;;;;;;;;;AAc/C,MAAa,mBAAmB,EAAE,eAAqC;CACrE,MAAM,iCAAsBC,wCAAmB;CAC/C,MAAM,kCAAuBC,iCAAY;CAEzC,MAAM,UAAU,QAAQ,UAAU,QAAQ;CAE1C,MAAM,sCACJ,OAAO,OAAe,cAAwC;AAC5D,MAAI,CAAC,QACH,OAAM,IAAI,MAAM,uDAAuD;EAGzE,MAAM,WAAW,MAAM,MAAM,GAAG,QAAQ,cAAc;GACpD,QAAQ;GACR,SAAS;IACP,gBAAgB;IAChB,eAAe,UAAU;IAC1B;GACD,MAAM,KAAK,UAAU;IAAE;IAAO;IAAW,CAAC;GAC3C,CAAC;AAEF,MAAI,CAAC,SAAS,GACZ,OAAM,IAAI,MAAM,2BAA2B,SAAS,aAAa;EAGnE,MAAM,SAAS,MAAM,SAAS,MAAM;AACpC,MAAI,OAAO,OACT,OAAM,IAAI,MAAM,mBAAmB,KAAK,UAAU,OAAO,OAAO,GAAG;AAGrE,SAAO,OAAO;IAEhB;EAAC;EAAQ;EAAS;EAAQ,CAC3B;CAED,MAAM,kCAAuB,YAAY;AAEvC,SAAOC,mDADU,MAAM,aAAaC,oDAAsB,EACrB,GAAG,KAAK,GAAG;IAC/C,CAAC,aAAa,CAAC;CAElB,MAAM,oDAAyC,YAA0C;AACvF,MAAI;GACF,MAAM,QAAQ,MAAM,8BAA8B;AAClD,OAAI,CAAC,MACH,OAAM,IAAI,MAAM,kDAAkD;GAEpE,MAAM,WAAW,MAAM,aAAa,MAAM;GAC1C,MAAM,eAAe,SAAS,GAAG,4BAA4B,QAAQ;GACrE,MAAM,iBAAiB,SAAS,GAAG,4BAA4B,UAAU;AAGzE,UAAO;IACL,cAH6BC,sDAAsB,aAAa;IAIhE,gBAHgCA,sDAAsB,eAAe;IAItE;WACM,KAAK;AACZ,0BAAO,SAAS,qDAAqD,IAAI;AACzE,UAAO;IAAE,cAAc;IAAW,gBAAgB;IAAW;;IAE9D,CAAC,aAAa,CAAC;CAElB,MAAM,kCACG;EACL;EACA;EACA;EACA;EACD,GACD;EAAC;EAAc;EAAU;EAA4B;EAAQ,CAC9D;AAED,QAAO,2CAAC,eAAe;EAAgB;EAAQ;GAAmC;;AAGpF,MAAa,yBAAyB;CACpC,MAAM,gCAAqB,eAAe;AAC1C,KAAI,CAAC,QACH,OAAM,IAAI,MAAM,yDAAyD;AAE3E,QAAO"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"graphqlContext.cjs","names":["configVersion","DEFAULT_PAGE_VARIANTS: PageVariantConfig[]","PageVariantTestType","orgLevelApiKeyAtom","baseUrlAtom","validateGraphQLOrgId","getMerchantOrgIdQuery","transformSnakeToCamel","validateAndTransformMountingConfig","v3pageVariants: PageVariantConfig[]","validateAndTransformPageVariants","mockV3ColorsConfig","mockV3FrontendConfig","ConfigVersionEnum"],"sources":["../../../src/contexts/graphqlContext/graphqlContext.tsx"],"sourcesContent":["import React, { ReactNode, createContext, useCallback, useContext, useMemo } from 'react';\nimport { useAtomValue } from 'jotai';\nimport { baseUrlAtom, orgLevelApiKeyAtom } from 'src/atoms/envive/enviveConfig';\nimport { getMerchantOrgIdQuery } from 'src/application/models/graphql/queries/getMerchantOrgIdQuery';\nimport { validateGraphQLOrgId } from 'src/application/models/validators/validateGraphQLOrgId';\nimport {\n  GetMerchantColorsQueryData,\n  GetMerchantFrontendConfigQueryData,\n} from 'src/application/models/graphql';\nimport { ColorMapping } from 'src/application/models/colorsConfig';\nimport { FrontendConfig } from 'src/application/models/frontendConfig';\nimport Logger from 'src/application/logging/logger';\nimport { configVersion } from 'src/types/config-versions';\nimport {\n  CamelCasedPropertiesDeep,\n  transformSnakeToCamel,\n  validateAndTransformMountingConfig,\n  validateAndTransformPageVariants,\n} from 'src/application/models';\nimport { FrontendConfigV3 } from 'src/application/models/frontendConfigV3';\nimport { ColorMappingV3 } from 'src/application/models/colorsConfigV3';\nimport { mockV3ColorsConfig, mockV3FrontendConfig } from './mockV3Config';\nimport { ConfigVersionEnum, Position, WidgetConfigV3 } from '../typesV3';\nimport {\n  OrgPageConfig,\n  PageVariantConfig,\n  PageVariantTestType,\n  WidgetMountingConfig,\n} from '../types';\n\ninterface BaseMeConfigQueryResponse {\n  me: {\n    org?: {\n      id: string;\n    };\n    getProductsConfigByVersion?: {\n      frontend?: {\n        values: CamelCasedPropertiesDeep<GetMerchantFrontendConfigQueryData>;\n      };\n      colors?: { values: CamelCasedPropertiesDeep<GetMerchantColorsQueryData> };\n    };\n  };\n}\nexport type ColorsConfigResponse = CamelCasedPropertiesDeep<ColorMapping>;\nexport type FrontendConfigResponse = CamelCasedPropertiesDeep<FrontendConfig>;\nexport type ColorsConfigV3Response = CamelCasedPropertiesDeep<ColorMappingV3>;\nexport type FrontendConfigV3Response = CamelCasedPropertiesDeep<FrontendConfigV3>;\n\nexport type GraphQlConfigValues = {\n  colorsConfig?: ColorsConfigResponse | ColorsConfigV3Response;\n  frontendConfig?: CamelCasedPropertiesDeep<FrontendConfig | FrontendConfigV3>;\n  orgPageConfig?: OrgPageConfig;\n};\n\ninterface GraphQLContextValue {\n  executeQuery: <T>(query: string, variables?: Record<string, unknown>) => Promise<T>;\n  getOrgId: () => Promise<string | undefined>;\n  getColorsAndFrontendConfig: () => Promise<GraphQlConfigValues>;\n  getV3Config: () => Promise<GraphQlConfigValues>;\n  getConfig: () => Promise<GraphQlConfigValues>;\n  isReady: boolean;\n}\n\nconst GraphQLContext = createContext<GraphQLContextValue | null>(null);\n\nconst colorsAndFrontendConfigQuery = () => `\n  query ($version: String = \"${configVersion()}\") {\n    me {\n      getProductsConfigByVersion(version: $version) {\n        frontend { values }\n        colors { values }\n        v_three_config { values }\n      }\n    }\n  }\n`;\n\ntype GraphQLProviderProps = {\n  children: ReactNode;\n  requestV3Config?: boolean;\n  mockV3ConfigToDeprecatedConfig?: boolean;\n};\n\nconst DEFAULT_PAGE_VARIANTS: PageVariantConfig[] = [\n  {\n    variantId: 'plp',\n    variantType: 'plp',\n    plpIdExtractor: 'url-resolver-plp-id',\n    widgetMounting: [],\n    variantTests: [\n      {\n        testType: PageVariantTestType.UrlResolver,\n      },\n    ],\n  },\n  {\n    variantId: 'pdp',\n    variantType: 'pdp',\n    productIdExtractor: 'url-resolver-product-id',\n    widgetMounting: [],\n    variantTests: [\n      {\n        testType: PageVariantTestType.UrlResolver,\n      },\n    ],\n  },\n];\n\nconst mapPositionToCamelCase = (position: string): Position => {\n  if (position === 'bottom-left') {\n    return 'bottomLeft';\n  }\n  if (position === 'middle-left') {\n    return 'middleLeft';\n  }\n  if (position === 'middle-right') {\n    return 'middleRight';\n  }\n  if (position === 'bottom-right') {\n    return 'bottomRight';\n  }\n  throw new Error(`Invalid position: ${position}`);\n};\n\n/**\n * This function is used to do some additional cleanup of the v3 frontend config to ensure that the config is in the correct format.\n */\nconst v3FrontendConfigCleanup = (\n  v3RootConfig: FrontendConfigV3Response,\n): FrontendConfigV3Response => {\n  const { uiConfigs } = v3RootConfig;\n  if (!uiConfigs) {\n    return v3RootConfig;\n  }\n  const { floatingButton, lookAndFeel } = uiConfigs as any;\n  if (!floatingButton || !lookAndFeel) {\n    return v3RootConfig;\n  }\n  const { fontSize, lineHeight } = lookAndFeel.typography as any;\n  return {\n    ...v3RootConfig,\n    uiConfigs: {\n      ...uiConfigs,\n      floatingButton: {\n        ...floatingButton,\n        position: mapPositionToCamelCase(\n          v3RootConfig.uiConfigs?.floatingButton?.position as string,\n        ),\n      },\n      lookAndFeel: {\n        ...lookAndFeel,\n        chatHeaderLogoDarkSrc: lookAndFeel.chatHeaderLogoDarkSrc || lookAndFeel.chatHeaderLogoSrc,\n        chatHeaderLogoLightSrc: lookAndFeel.chatHeaderLogoLightSrc || lookAndFeel.chatHeaderLogoSrc,\n        typography: {\n          ...lookAndFeel.typography,\n          fontSize: {\n            // The fonts sizes are defined differently in the backend config\n            // so we need to map the values to the correct camel case keys\n            b1: fontSize?.b1 || fontSize?.b_1,\n            b2: fontSize?.b2 || fontSize?.b_2,\n            b3: fontSize?.b3 || fontSize?.b_3,\n            b4: fontSize?.b4 || fontSize?.b_4,\n            b5: fontSize?.b5 || fontSize?.b_5,\n            h1: fontSize?.h1 || fontSize?.h_1,\n            h2: fontSize?.h2 || fontSize?.h_2,\n            h3: fontSize?.h3 || fontSize?.h_3,\n            l1: fontSize?.l1 || fontSize?.l_1,\n            l2: fontSize?.l2 || fontSize?.l_2,\n            t1: fontSize?.t1 || fontSize?.t_1,\n            t2: fontSize?.t2 || fontSize?.t_2,\n            t3: fontSize?.t3 || fontSize?.t_3,\n          },\n          lineHeight: {\n            ...lookAndFeel.typography.lineHeight,\n            '114': lineHeight?.lh_114 || lineHeight?.[114],\n            '116': lineHeight?.lh_116 || lineHeight?.[116],\n            '118': lineHeight?.lh_118 || lineHeight?.[118],\n            '120': lineHeight?.lh_120 || lineHeight?.[120],\n            '124': lineHeight?.lh_124 || lineHeight?.[124],\n            '128': lineHeight?.lh_128 || lineHeight?.[128],\n            '130': lineHeight?.lh_130 || lineHeight?.[130],\n            '133': lineHeight?.lh_133 || lineHeight?.[133],\n            '140': lineHeight?.lh_140 || lineHeight?.[140],\n            '148': lineHeight?.lh_148 || lineHeight?.[148],\n          },\n        },\n      },\n    },\n  };\n};\n\nexport const GraphQLProvider = ({\n  children,\n  requestV3Config = false,\n  mockV3ConfigToDeprecatedConfig = false,\n}: GraphQLProviderProps) => {\n  const apiKey = useAtomValue(orgLevelApiKeyAtom);\n  const baseUrl = useAtomValue(baseUrlAtom);\n  const isReady = useMemo(() => Boolean(apiKey && baseUrl), [apiKey, baseUrl]);\n\n  const executeQuery = useCallback(\n    async (query: string, variables?: Record<string, unknown>) => {\n      if (!isReady) {\n        throw new Error('GraphQL client not ready - missing apiKey or baseUrl');\n      }\n\n      const response = await fetch(`${baseUrl}/v1/graphql`, {\n        method: 'POST',\n        headers: {\n          'Content-Type': 'application/json',\n          Authorization: `Bearer ${apiKey}`,\n        },\n        body: JSON.stringify({ query, variables }),\n      });\n\n      if (!response.ok) {\n        throw new Error(`GraphQL request failed: ${response.statusText}`);\n      }\n\n      const result = await response.json();\n      if (result.errors) {\n        throw new Error(`GraphQL errors: ${JSON.stringify(result.errors)}`);\n      }\n\n      return result.data;\n    },\n    [apiKey, baseUrl, isReady],\n  );\n\n  const getOrgId = useCallback(async () => {\n    const response = await executeQuery(getMerchantOrgIdQuery);\n    return validateGraphQLOrgId(response.me.org?.id);\n  }, [executeQuery]);\n\n  const getV3Config = useCallback(async (): Promise<GraphQlConfigValues> => {\n    try {\n      const query = await colorsAndFrontendConfigQuery();\n      if (!query) {\n        throw new Error('Colors and frontend config query is not defined');\n      }\n      const response = await executeQuery(query);\n\n      // We may update this root config location in the future\n      const v3RootConfig = response.me.getProductsConfigByVersion?.v_three_config?.values;\n\n      const v3FrontendConfig = v3FrontendConfigCleanup(\n        transformSnakeToCamel(v3RootConfig) as FrontendConfigV3Response,\n      );\n\n      const v3MountingConfigsArray = (transformSnakeToCamel(v3RootConfig?.mounting_configs) ??\n        []) as unknown as { key: string; config: WidgetMountingConfig }[];\n\n      const v3MountingConfigs = v3MountingConfigsArray.reduce(\n        (acc, { key, config }) => {\n          acc[key] = validateAndTransformMountingConfig(config, key);\n          return acc;\n        },\n        {} as Record<string, WidgetMountingConfig>,\n      );\n\n      const v3widgetConfigsArray = (transformSnakeToCamel(v3RootConfig?.widget_configs) ??\n        []) as unknown as WidgetConfigV3[];\n      const v3WidgetConfigs = Object.fromEntries(\n        v3widgetConfigsArray?.map(({ widgetConfigId, ...rest }: WidgetConfigV3) => [\n          widgetConfigId,\n          { widgetConfigId, ...rest } as WidgetConfigV3,\n        ]),\n      ) as Record<string, WidgetConfigV3>;\n      const v3pageVariants: PageVariantConfig[] = Array.isArray(v3RootConfig?.page_variants)\n        ? v3RootConfig?.page_variants.map(validateAndTransformPageVariants)\n        : DEFAULT_PAGE_VARIANTS;\n\n      const v3ColorsConfig = transformSnakeToCamel(v3RootConfig?.colors?.values);\n\n      // If the v3 root config is not found and we are configured to return the deprecated config, we will return the mocked config\n      if (!v3RootConfig && mockV3ConfigToDeprecatedConfig) {\n        const isSemanticColors = !window.location.href.includes('globals=merchant');\n        const colorsConfig = mockV3ColorsConfig;\n        const frontendConfig = mockV3FrontendConfig;\n        return {\n          colorsConfig: isSemanticColors\n            ? (colorsConfig as ColorsConfigV3Response)\n            : (v3ColorsConfig as ColorsConfigV3Response),\n          frontendConfig: frontendConfig as FrontendConfigV3Response,\n        };\n      }\n\n      return {\n        colorsConfig: v3ColorsConfig as ColorsConfigV3Response,\n        frontendConfig: {\n          ...(v3FrontendConfig as FrontendConfigV3Response),\n          // Need to replace the automatic widget configs with the object based ones\n          widgetConfigs: v3WidgetConfigs,\n        },\n        orgPageConfig: {\n          pageVariants: v3pageVariants,\n          widgetConfigs: v3WidgetConfigs,\n          mountingConfigs: v3MountingConfigs,\n        },\n        // TODO: Add widgets and other config here\n      };\n    } catch (err) {\n      Logger.logError('Error fetching graphql colors and frontend config', err);\n      return { colorsConfig: undefined, frontendConfig: undefined };\n    }\n  }, [executeQuery, mockV3ConfigToDeprecatedConfig]);\n\n  const getColorsAndFrontendConfig = useCallback(async (): Promise<GraphQlConfigValues> => {\n    try {\n      const query = await colorsAndFrontendConfigQuery();\n      if (!query) {\n        throw new Error('Colors and frontend config query is not defined');\n      }\n      const response = await executeQuery(query);\n      if (\n        response.me.getProductsConfigByVersion?.version !== ConfigVersionEnum.V3 &&\n        !mockV3ConfigToDeprecatedConfig\n      ) {\n        const colorsConfig = response.me.getProductsConfigByVersion?.colors?.values;\n        const frontendConfig = response.me.getProductsConfigByVersion?.frontend?.values;\n        const transformedColorConfig = transformSnakeToCamel(colorsConfig);\n        const transformedFrontendConfig = transformSnakeToCamel(frontendConfig);\n        return {\n          colorsConfig: transformedColorConfig as ColorsConfigResponse,\n          frontendConfig: transformedFrontendConfig as FrontendConfigResponse,\n        };\n      }\n      // TODO: REMOVE MOCKED CONFIG ONCE WE HAVE THE NEW CONFIG IMPLEMENTED ON BACKEND\n      const merchantColorsConfig = response.me.getProductsConfigByVersion?.colors?.values;\n      const transformedMerchantColorConfig = transformSnakeToCamel(merchantColorsConfig);\n\n      const isSemanticColors = !window.location.href.includes('globals=merchant');\n\n      const colorsConfig = mockV3ColorsConfig;\n      const frontendConfig = mockV3FrontendConfig;\n\n      return {\n        colorsConfig: isSemanticColors\n          ? (colorsConfig as ColorsConfigV3Response)\n          : (transformedMerchantColorConfig as ColorsConfigV3Response),\n        frontendConfig: frontendConfig as FrontendConfigV3Response,\n      };\n    } catch (err) {\n      Logger.logError('Error fetching graphql colors and frontend config', err);\n      return { colorsConfig: undefined, frontendConfig: undefined };\n    }\n  }, [executeQuery]);\n\n  const getConfig = useCallback(async (): Promise<GraphQlConfigValues> => {\n    console.log('GraphQLProvider: getConfig: requestV3Config', requestV3Config);\n    if (requestV3Config) {\n      return getV3Config();\n    }\n    return getColorsAndFrontendConfig();\n  }, [getColorsAndFrontendConfig, getV3Config, requestV3Config]);\n\n  const value = useMemo(\n    () => ({\n      executeQuery,\n      getOrgId,\n      getColorsAndFrontendConfig,\n      getV3Config,\n      getConfig,\n      isReady,\n    }),\n    [executeQuery, getOrgId, getColorsAndFrontendConfig, getV3Config, getConfig, isReady],\n  );\n\n  return <GraphQLContext.Provider value={value}>{children}</GraphQLContext.Provider>;\n};\n\nexport const useGraphQLClient = () => {\n  const context = useContext(GraphQLContext);\n  if (!context) {\n    throw new Error('useGraphQLClient must be used within a GraphQLProvider');\n  }\n  return context;\n};\n"],"mappings":"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"}

package/dist/contexts/graphqlContext/graphqlContext.d.cts

@@ -1,29 +1,41 @@
 import { CamelCasedPropertiesDeep } from "../../application/models/utilityTypes/camelCasedPropertiesDeep.cjs";
 import { ColorMapping } from "../../application/models/colorsConfig.cjs";
+import { OrgPageConfig } from "../types.cjs";
 import { FrontendConfig } from "../../application/models/frontendConfig.cjs";
+import { FrontendConfigV3 } from "../../application/models/frontendConfigV3.cjs";
+import { ColorMappingV3 } from "../../application/models/colorsConfigV3.cjs";
 import { ReactNode } from "react";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
 
 //#region src/contexts/graphqlContext/graphqlContext.d.ts
 type ColorsConfigResponse = CamelCasedPropertiesDeep<ColorMapping>;
 type FrontendConfigResponse = CamelCasedPropertiesDeep<FrontendConfig>;
+type ColorsConfigV3Response = CamelCasedPropertiesDeep<ColorMappingV3>;
+type FrontendConfigV3Response = CamelCasedPropertiesDeep<FrontendConfigV3>;
 type GraphQlConfigValues = {
-  colorsConfig?: ColorsConfigResponse;
-  frontendConfig?: CamelCasedPropertiesDeep<FrontendConfig>;
+  colorsConfig?: ColorsConfigResponse | ColorsConfigV3Response;
+  frontendConfig?: CamelCasedPropertiesDeep<FrontendConfig | FrontendConfigV3>;
+  orgPageConfig?: OrgPageConfig;
 };
 interface GraphQLContextValue {
   executeQuery: <T>(query: string, variables?: Record<string, unknown>) => Promise<T>;
   getOrgId: () => Promise<string | undefined>;
   getColorsAndFrontendConfig: () => Promise<GraphQlConfigValues>;
+  getV3Config: () => Promise<GraphQlConfigValues>;
+  getConfig: () => Promise<GraphQlConfigValues>;
   isReady: boolean;
 }
 type GraphQLProviderProps = {
   children: ReactNode;
+  requestV3Config?: boolean;
+  mockV3ConfigToDeprecatedConfig?: boolean;
 };
 declare const GraphQLProvider: ({
-  children
+  children,
+  requestV3Config,
+  mockV3ConfigToDeprecatedConfig
 }: GraphQLProviderProps) => react_jsx_runtime0.JSX.Element;
 declare const useGraphQLClient: () => GraphQLContextValue;
 //#endregion
-export { ColorsConfigResponse, FrontendConfigResponse, GraphQLProvider, GraphQlConfigValues, useGraphQLClient };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+export { ColorsConfigResponse, ColorsConfigV3Response, FrontendConfigResponse, FrontendConfigV3Response, GraphQLProvider, GraphQlConfigValues, useGraphQLClient };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/contexts/graphqlContext/graphqlContext.d.ts

@@ -1,29 +1,41 @@
 import { CamelCasedPropertiesDeep } from "../../application/models/utilityTypes/camelCasedPropertiesDeep.js";
 import { ColorMapping } from "../../application/models/colorsConfig.js";
+import { OrgPageConfig } from "../types.js";
 import { FrontendConfig } from "../../application/models/frontendConfig.js";
+import { FrontendConfigV3 } from "../../application/models/frontendConfigV3.js";
+import { ColorMappingV3 } from "../../application/models/colorsConfigV3.js";
 import { ReactNode } from "react";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
 
 //#region src/contexts/graphqlContext/graphqlContext.d.ts
 type ColorsConfigResponse = CamelCasedPropertiesDeep<ColorMapping>;
 type FrontendConfigResponse = CamelCasedPropertiesDeep<FrontendConfig>;
+type ColorsConfigV3Response = CamelCasedPropertiesDeep<ColorMappingV3>;
+type FrontendConfigV3Response = CamelCasedPropertiesDeep<FrontendConfigV3>;
 type GraphQlConfigValues = {
-  colorsConfig?: ColorsConfigResponse;
-  frontendConfig?: CamelCasedPropertiesDeep<FrontendConfig>;
+  colorsConfig?: ColorsConfigResponse | ColorsConfigV3Response;
+  frontendConfig?: CamelCasedPropertiesDeep<FrontendConfig | FrontendConfigV3>;
+  orgPageConfig?: OrgPageConfig;
 };
 interface GraphQLContextValue {
   executeQuery: <T>(query: string, variables?: Record<string, unknown>) => Promise<T>;
   getOrgId: () => Promise<string | undefined>;
   getColorsAndFrontendConfig: () => Promise<GraphQlConfigValues>;
+  getV3Config: () => Promise<GraphQlConfigValues>;
+  getConfig: () => Promise<GraphQlConfigValues>;
   isReady: boolean;
 }
 type GraphQLProviderProps = {
   children: ReactNode;
+  requestV3Config?: boolean;
+  mockV3ConfigToDeprecatedConfig?: boolean;
 };
 declare const GraphQLProvider: ({
-  children
+  children,
+  requestV3Config,
+  mockV3ConfigToDeprecatedConfig
 }: GraphQLProviderProps) => react_jsx_runtime0.JSX.Element;
 declare const useGraphQLClient: () => GraphQLContextValue;
 //#endregion
-export { ColorsConfigResponse, FrontendConfigResponse, GraphQLProvider, GraphQlConfigValues, useGraphQLClient };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3JhcGhxbENvbnRleHQuZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29udGV4dHMvZ3JhcGhxbENvbnRleHQvZ3JhcGhxbENvbnRleHQuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZWFjdE5vZGUgfSBmcm9tICdyZWFjdCc7XG5pbXBvcnQgeyBDb2xvck1hcHBpbmcgfSBmcm9tICdzcmMvYXBwbGljYXRpb24vbW9kZWxzL2NvbG9yc0NvbmZpZyc7XG5pbXBvcnQgeyBGcm9udGVuZENvbmZpZyB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMvZnJvbnRlbmRDb25maWcnO1xuaW1wb3J0IHsgQ2FtZWxDYXNlZFByb3BlcnRpZXNEZWVwIH0gZnJvbSAnc3JjL2FwcGxpY2F0aW9uL21vZGVscyc7XG5leHBvcnQgdHlwZSBDb2xvcnNDb25maWdSZXNwb25zZSA9IENhbWVsQ2FzZWRQcm9wZXJ0aWVzRGVlcDxDb2xvck1hcHBpbmc+O1xuZXhwb3J0IHR5cGUgRnJvbnRlbmRDb25maWdSZXNwb25zZSA9IENhbWVsQ2FzZWRQcm9wZXJ0aWVzRGVlcDxGcm9udGVuZENvbmZpZz47XG5leHBvcnQgdHlwZSBHcmFwaFFsQ29uZmlnVmFsdWVzID0ge1xuICAgIGNvbG9yc0NvbmZpZz86IENvbG9yc0NvbmZpZ1Jlc3BvbnNlO1xuICAgIGZyb250ZW5kQ29uZmlnPzogQ2FtZWxDYXNlZFByb3BlcnRpZXNEZWVwPEZyb250ZW5kQ29uZmlnPjtcbn07XG5pbnRlcmZhY2UgR3JhcGhRTENvbnRleHRWYWx1ZSB7XG4gICAgZXhlY3V0ZVF1ZXJ5OiA8VD4ocXVlcnk6IHN0cmluZywgdmFyaWFibGVzPzogUmVjb3JkPHN0cmluZywgdW5rbm93bj4pID0+IFByb21pc2U8VD47XG4gICAgZ2V0T3JnSWQ6ICgpID0+IFByb21pc2U8c3RyaW5nIHwgdW5kZWZpbmVkPjtcbiAgICBnZXRDb2xvcnNBbmRGcm9udGVuZENvbmZpZzogKCkgPT4gUHJvbWlzZTxHcmFwaFFsQ29uZmlnVmFsdWVzPjtcbiAgICBpc1JlYWR5OiBib29sZWFuO1xufVxudHlwZSBHcmFwaFFMUHJvdmlkZXJQcm9wcyA9IHtcbiAgICBjaGlsZHJlbjogUmVhY3ROb2RlO1xufTtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IEdyYXBoUUxQcm92aWRlcjogKHsgY2hpbGRyZW4gfTogR3JhcGhRTFByb3ZpZGVyUHJvcHMpID0+IGltcG9ydChcInJlYWN0L2pzeC1ydW50aW1lXCIpLkpTWC5FbGVtZW50O1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgdXNlR3JhcGhRTENsaWVudDogKCkgPT4gR3JhcGhRTENvbnRleHRWYWx1ZTtcbmV4cG9ydCB7fTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7OztBQUtBLElBQVcsdUJBQXVCO0NBQUM7T0FBVztPQUFvQjtDQUFXO0FBQzdFLElBQVcseUJBQXVCO0NBQUE7T0FBQTtPQUFBO0NBQUE7QUFDbEMsSUFBVyxzQkFBc0I7Q0FBQztPQUFLO09BQUE7T0FBQTtDQUFBO0FBQ3ZDLElBQUksc0JBQXNCO0NBQUM7T0FBVztPQUFjO09BQVM7T0FBQTtPQUFBO09BQUE7Q0FBQTtBQUM3RCxJQUFDLHVCQUFBLENBQUEsV0FBQSxVQUFBO0FBQ0QsSUFBVyxrQkFBa0I7Q0FBQztPQUFBO09BQUE7T0FBQSxtQkFBQSxJQUFBO0NBQUE7QUFDOUIsSUFBVyxtQkFBbUIsQ0FBQyxXQUFXLG9CQUFvQiJ9
+export { ColorsConfigResponse, ColorsConfigV3Response, FrontendConfigResponse, FrontendConfigV3Response, GraphQLProvider, GraphQlConfigValues, useGraphQLClient };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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