@blux.ai/web-sdk 2.2.11 → 2.2.13

package/dist/BluxClient.js

@@ -0,0 +1,732 @@
+import { version } from "./package.js";
+import { DevicePlatform } from "./apis/APIs.js";
+import { createCrmEvent } from "./apis/createCrmEvent.js";
+import { collectEvent } from "./apis/createEvent.js";
+import { getItemRecommendations } from "./apis/getItemRecommendations.js";
+import { initialize } from "./apis/initialize.js";
+import { notificationsUpdate } from "./apis/notificationsUpdate.js";
+import { signIn } from "./apis/signIn.js";
+import { signOut } from "./apis/signOut.js";
+import { updateProperties } from "./apis/updateProperties.js";
+import { Logger } from "./utils/Logger.js";
+import { AndroidBridge } from "./bridges/AndroidBridge.js";
+import { FlutterBridge } from "./bridges/FlutterBridge.js";
+import { IosBridge } from "./bridges/IosBridge.js";
+import { RNBridge } from "./bridges/RNBridge.js";
+import { BLUX_ATTRIBUTES } from "./constants/BLUX_ATTRIBUTES.js";
+import { AddSectionViewEvent } from "./events/AddSectionViewEvent.js";
+import { AddPageVisitEvent } from "./events/AddPageVisitEvent.js";
+import { AddClickEvent } from "./events/AddClickEvent.js";
+import { VisitEvent } from "./events/VisitEvent.js";
+import "./events/index.js";
+import { LocalStorage } from "./utils/LocalStorage.js";
+import { getOnlineAndVisible$ } from "./utils/observables.js";
+import { filterNullable } from "./utils/operators.js";
+import { SessionStorage } from "./utils/SessionStorage.js";
+import axios from "axios";
+import ObjectId from "bson-objectid";
+import dayjs from "dayjs";
+import { BehaviorSubject, NEVER, Subject, bufferTime, catchError, combineLatest, concatMap, debounceTime, filter, first, firstValueFrom, from, groupBy, map, merge, mergeMap, skip, switchMap, throwError, timeout, timer } from "rxjs";
+
+//#region src/BluxClient.ts
+var BluxClient = class BluxClient {
+	isBrowser = typeof window !== "undefined";
+	static EMPTY_REC_RESPONSE = {
+		item_ids: [],
+		metadata: {},
+		recommendation_id: null
+	};
+	api = axios.create();
+	sdkInfo = {
+		type: DevicePlatform.browser,
+		version
+	};
+	bluxUser$ = new BehaviorSubject(void 0);
+	/**
+	* 내부 async 작업을 1개씩 직렬로 처리하는 큐입니다.
+	* `enqueueRequest()`로 넣으면, 호출자는 완료 시점까지 `await` 할 수 있습니다.
+	*/
+	apiRequestQueue$ = new Subject();
+	inappQueue$ = new BehaviorSubject(void 0);
+	eventQueue$ = new Subject();
+	userPropertiesQueue$ = new Subject();
+	INITIAL_NEXT_POLL_DELAY_MS = 10 * 1e3;
+	nextPollDelayMs$ = new BehaviorSubject(this.INITIAL_NEXT_POLL_DELAY_MS);
+	cachedNextPollDelayMs = this.INITIAL_NEXT_POLL_DELAY_MS;
+	lastPollTimestamp = Date.now();
+	bluxApplicationId;
+	bluxAPIKey;
+	customDeviceId;
+	bridge = null;
+	impressedElements = [];
+	intersectionObservingElements = [];
+	intersectionObserver = this.isBrowser ? new IntersectionObserver((entries) => {
+		entries.forEach((entry) => {
+			this.intersectionEntry$.next(entry);
+		});
+	}) : null;
+	intersectionEntry$ = new Subject();
+	hitElements = [];
+	currentInappCleanup = null;
+	inAppCustomActionHandlers = /* @__PURE__ */ new Set();
+	resolveBridge(bridgeOptions) {
+		if ("useRNBridge" in bridgeOptions && bridgeOptions.useRNBridge) return new RNBridge();
+		if ("bridgePlatform" in bridgeOptions && bridgeOptions.bridgePlatform) switch (bridgeOptions.bridgePlatform) {
+			case "none": return null;
+			case "android": return new AndroidBridge();
+			case "ios": return new IosBridge();
+			case "react-native": return new RNBridge();
+			case "flutter": return new FlutterBridge();
+			default: {
+				const exhaustiveCheck = bridgeOptions.bridgePlatform;
+				Logger.error(`Unknown bridge platform: ${exhaustiveCheck}`, { tags: { from: "resolveBridge" } });
+			}
+		}
+		return null;
+	}
+	constructor({ bluxApplicationId, bluxAPIKey, customDeviceId, ...bridgeOptions }, completionCallback) {
+		this.bluxApplicationId = bluxApplicationId;
+		this.bluxAPIKey = bluxAPIKey;
+		this.customDeviceId = customDeviceId;
+		if (!this.isBrowser) {
+			completionCallback?.({ success: true });
+			return;
+		}
+		const baseUrl = window?._BLUX_SDK_?.baseUrl ?? "https://api.blux.ai/prod";
+		this.api.defaults.baseURL = baseUrl;
+		this.bridge = this.resolveBridge(bridgeOptions);
+		this.apiRequestQueue$.pipe(concatMap(async (job) => {
+			try {
+				const result = await job.action();
+				job.resolve(result);
+			} catch (error) {
+				job.reject(error);
+			}
+		})).subscribe();
+		/**
+		* (1) 보내야할 이벤트를 100ms씩 뭉쳐서 보내고, 1개 이상 쌓여있을 때 api 요청
+		* (2) collectEvent의 응답에서 온 nextPollDelayMs 값 만큼 이후에 빈 배열로 api 요청 (1)로 보내면 초기화됨
+		*/
+		if (!this.bridge) merge(this.eventQueue$.pipe(bufferTime(100), filter((requests) => requests.length > 0)), combineLatest([this.nextPollDelayMs$, getOnlineAndVisible$()]).pipe(switchMap(([delay, isOnlineAndVisible]) => {
+			if (!isOnlineAndVisible || delay == null) return NEVER;
+			const targetTime = this.lastPollTimestamp + delay;
+			return timer(Math.max(0, targetTime - Date.now()));
+		}), map(() => []))).pipe(concatMap(async (requests) => {
+			this.nextPollDelayMs$.next(null);
+			try {
+				const bluxUser = await this.getBluxUserWithTimeout();
+				const events = requests.map((request) => ({
+					...request,
+					blux_id: bluxUser.id,
+					device_id: bluxUser.deviceId
+				}));
+				const { data: { nextPollDelayMs, inapp } } = await this.enqueueRequest(() => collectEvent(this.api, {
+					blux_user_id: bluxUser.id,
+					application_id: bluxUser.applicationId
+				}, {
+					device_id: bluxUser.deviceId,
+					events
+				}, this.generateApiHeader(bluxUser)));
+				this.lastPollTimestamp = Date.now();
+				this.cachedNextPollDelayMs = nextPollDelayMs;
+				this.nextPollDelayMs$.next(Math.max(nextPollDelayMs, 3e3));
+				if (inapp) this.inappQueue$.next(inapp);
+			} catch (error) {
+				Logger.error(error, { tags: { from: "eventQueue" } });
+				this.lastPollTimestamp = Date.now();
+				if (this.cachedNextPollDelayMs !== null) {
+					const nextPollDelay = this.cachedNextPollDelayMs > 1e3 * 60 * 60 * 24 ? this.cachedNextPollDelayMs : this.cachedNextPollDelayMs * 2;
+					this.cachedNextPollDelayMs = nextPollDelay;
+					this.nextPollDelayMs$.next(nextPollDelay);
+				}
+			}
+		})).subscribe();
+		this.userPropertiesQueue$.pipe(bufferTime(100), filter((items) => items.length > 0), concatMap(async (items) => {
+			try {
+				const bluxUser = await this.getBluxUserWithTimeout();
+				const mergedUserProperties = items.reduce((acc, item) => ({
+					...acc,
+					...item.userProperties ?? {}
+				}), {});
+				const mergedCustomUserProperties = items.reduce((acc, item) => ({
+					...acc,
+					...item.customUserProperties ?? {}
+				}), {});
+				const payload = {};
+				if (Object.keys(mergedUserProperties).length > 0) payload.user_properties = mergedUserProperties;
+				if (Object.keys(mergedCustomUserProperties).length > 0) payload.custom_user_properties = mergedCustomUserProperties;
+				if (Object.keys(payload).length === 0) {
+					items.forEach((item) => item.resolve());
+					return;
+				}
+				await this.enqueueRequest(() => updateProperties(this.api, {
+					application_id: bluxUser.applicationId,
+					blux_user_id: bluxUser.id
+				}, payload, this.generateApiHeader(bluxUser)));
+				items.forEach((item) => item.resolve());
+			} catch (error) {
+				items.forEach((item) => item.reject(error));
+				Logger.error(error, { tags: { from: "userPropertiesQueue" } });
+			}
+		})).subscribe();
+		this.bluxUser$.subscribe((bluxUser) => {
+			if (bluxUser) SessionStorage.setBluxUserId(bluxUser.id);
+		});
+		if (!this.bridge) this.inappQueue$.pipe(filterNullable()).pipe(concatMap((inapp) => getOnlineAndVisible$().pipe(first(Boolean), concatMap(() => from(this.displayInapp(inapp)))))).subscribe();
+		this.init().then(() => {
+			completionCallback?.({ success: true });
+		}).catch((error) => {
+			completionCallback?.({
+				success: false,
+				errorMessage: error.message
+			});
+		});
+	}
+	async enqueueRequest(action) {
+		return new Promise((resolve, reject) => {
+			const item = {
+				action,
+				resolve,
+				reject
+			};
+			this.apiRequestQueue$.next(item);
+		});
+	}
+	generateApiHeader({ bluxAPIKey }) {
+		return { Authorization: bluxAPIKey };
+	}
+	async displayInapp(inapp) {
+		return new Promise((resolve) => {
+			const bluxUser = this.bluxUser$.getValue();
+			const hideTimestamp = LocalStorage.getInappHideTimestamp(inapp.inappId);
+			if (hideTimestamp !== null && dayjs().isBefore(dayjs(hideTimestamp))) return resolve(true);
+			const iframeElement = document.createElement("iframe");
+			const headInjection = `<script>
+        (function() {
+          var origReplaceState = history.replaceState;
+          var origPushState = history.pushState;
+          history.replaceState = function() {
+            try { return origReplaceState.apply(this, arguments); }
+            catch(e) { console.debug('[Blux] history.replaceState blocked in blob context'); }
+          };
+          history.pushState = function() {
+            try { return origPushState.apply(this, arguments); }
+            catch(e) { console.debug('[Blux] history.pushState blocked in blob context'); }
+          };
+        })();
+      <\/script><base href="${inapp.baseUrl}/">`;
+			const htmlWithBase = inapp.htmlString.includes("<head>") ? inapp.htmlString.replace("<head>", `<head>${headInjection}`) : inapp.htmlString;
+			const blob = new Blob([htmlWithBase], { type: "text/html" });
+			const blobUrl = URL.createObjectURL(blob);
+			iframeElement.sandbox.add("allow-scripts", "allow-same-origin", "allow-forms");
+			iframeElement.src = blobUrl;
+			iframeElement.style.position = "fixed";
+			iframeElement.style.width = `${window.innerWidth}px`;
+			iframeElement.style.height = `${window.innerHeight}px`;
+			iframeElement.style.top = "0";
+			iframeElement.style.left = "0";
+			iframeElement.style.zIndex = "9999";
+			iframeElement.id = `blux-inapp-${inapp.inappId}`;
+			document.body.appendChild(iframeElement);
+			let urlChangeSubscription = null;
+			const cleanup = () => {
+				URL.revokeObjectURL(blobUrl);
+				iframeElement.remove();
+				window.removeEventListener("message", handleMessage);
+				window.visualViewport?.removeEventListener("resize", handleViewportChange);
+				window.visualViewport?.removeEventListener("scroll", handleViewportChange);
+				urlChangeSubscription?.unsubscribe();
+				this.currentInappCleanup = null;
+				resolve(inapp.inappId);
+			};
+			this.currentInappCleanup = cleanup;
+			const handleViewportChange = () => {
+				const width = window.visualViewport?.width ?? window.innerWidth;
+				const height = window.visualViewport?.height ?? window.innerHeight;
+				const left = window.visualViewport?.offsetLeft ?? 0;
+				const top = window.visualViewport?.offsetTop ?? 0;
+				iframeElement.style.width = `${width}px`;
+				iframeElement.style.height = `${height}px`;
+				iframeElement.style.left = `${left}px`;
+				iframeElement.style.top = `${top}px`;
+			};
+			const handleMessage = (event) => {
+				if (event.source !== iframeElement.contentWindow) return;
+				const message = event.data;
+				if (message.action === "resize") {
+					const { height, location } = message.data;
+					iframeElement.style.width = "90vw";
+					iframeElement.style.maxWidth = "448px";
+					iframeElement.style.height = `${height}px`;
+					iframeElement.style.left = "50%";
+					iframeElement.style.transform = "translateX(-50%)";
+					if (location === "top") {
+						iframeElement.style.top = "0";
+						iframeElement.style.bottom = "auto";
+					} else {
+						iframeElement.style.top = "auto";
+						iframeElement.style.bottom = "0";
+					}
+					window.visualViewport?.removeEventListener("resize", handleViewportChange);
+					window.visualViewport?.removeEventListener("scroll", handleViewportChange);
+					return;
+				}
+				if (message.action === "hide") {
+					const { days_to_hide } = message.data;
+					if (days_to_hide !== 0) {
+						const expiresAt = dayjs().add(days_to_hide, "days").valueOf();
+						LocalStorage.setInappHideTimestamp(inapp.inappId, expiresAt);
+					}
+				} else if (message.action === "link") {
+					const crmEventPromise = bluxUser ? this.enqueueRequest(() => createCrmEvent(this.api, { application_id: this.bluxApplicationId }, {
+						notification_id: inapp.notificationId,
+						crm_event_type: "inapp_opened",
+						captured_at: (/* @__PURE__ */ new Date()).toISOString()
+					}, this.generateApiHeader(bluxUser))) : Promise.resolve();
+					if (message.data.is_blux_landing) {} else {
+						const { url, open_in_new_tab, opened_by_iframe } = message.data;
+						const needsLocationChange = opened_by_iframe && !open_in_new_tab;
+						if (this.bluxApplicationId === "6878af275ead5a75abbdacd7") crmEventPromise.finally(() => {
+							window.top?.postMessage({
+								type: "blux_inapp_message",
+								url
+							}, window.location.origin);
+						});
+						else if (needsLocationChange) crmEventPromise.finally(() => {
+							window.location.href = url;
+						});
+						else if (!opened_by_iframe) if (open_in_new_tab) window.open(url, "_blank");
+						else window.location.href = url;
+					}
+				} else if (message.action === "custom_action") {
+					const { action_id, data, should_dismiss } = message.data;
+					for (const handler of this.inAppCustomActionHandlers) try {
+						handler({
+							actionId: action_id,
+							data
+						});
+					} catch (error) {
+						Logger.error(error, { tags: { from: "inAppCustomActionHandler" } });
+					}
+					if (!should_dismiss) return;
+				} else if (message.action === "inapp_opened") {
+					if (bluxUser) this.enqueueRequest(() => createCrmEvent(this.api, { application_id: this.bluxApplicationId }, {
+						notification_id: inapp.notificationId,
+						crm_event_type: "inapp_opened",
+						captured_at: (/* @__PURE__ */ new Date()).toISOString()
+					}, this.generateApiHeader(bluxUser)));
+					return;
+				}
+				cleanup();
+			};
+			urlChangeSubscription = this.urlAndRef$.pipe(filterNullable(), skip(1), first()).subscribe(() => {
+				cleanup();
+			});
+			window.visualViewport?.addEventListener("resize", handleViewportChange);
+			window.visualViewport?.addEventListener("scroll", handleViewportChange);
+			window.addEventListener("message", handleMessage);
+			if (bluxUser) this.enqueueRequest(() => notificationsUpdate(this.api, {
+				application_id: this.bluxApplicationId,
+				notification_id: inapp.notificationId
+			}, { status: "received" }, this.generateApiHeader(bluxUser)));
+		});
+	}
+	async init() {
+		this.handleUrlAndRef();
+		this.urlAndRef$.pipe(filterNullable()).subscribe(() => {
+			this.sendEvent(new AddPageVisitEvent({}));
+		});
+		if (this.bridge) {
+			this.bridge.initialize({
+				bluxApplicationId: this.bluxApplicationId,
+				bluxAPIKey: this.bluxAPIKey,
+				customDeviceId: this.customDeviceId
+			});
+			return;
+		}
+		const blux_user_id = new URLSearchParams(window.location.search).get("blux_user_id");
+		const sessionId = SessionStorage.getSessionId() ?? new ObjectId().toHexString();
+		SessionStorage.setSessionId(sessionId);
+		if (!SessionStorage.getBluxUserId()) this.sendEvent(new VisitEvent({}));
+		Logger.debug(`Init with application id: ${this.bluxApplicationId}`);
+		const deviceId = LocalStorage.getDeviceId();
+		if (!deviceId) Logger.debug("No saved Device ID, register a new one.");
+		this.registerHitTracker();
+		this.urlAndRef$.pipe(filterNullable()).subscribe(() => {
+			this.impressedElements = [];
+		});
+		this.registerImpressionTracker();
+		new MutationObserver(() => {
+			this.registerImpressionTracker();
+		}).observe(document, {
+			subtree: true,
+			childList: true
+		});
+		const MIN_IMPRESSION_TIME = 500;
+		this.intersectionEntry$.pipe(groupBy((entry) => entry.target), mergeMap((group$) => group$.pipe(debounceTime(MIN_IMPRESSION_TIME), filter((entry) => entry.isIntersecting)))).subscribe((entry) => {
+			const trackingId = entry.target.getAttribute(BLUX_ATTRIBUTES.tracking_id);
+			if (!trackingId) {
+				Logger.warning(`Tracking ID is not found in the parent elements. Please check the tracking ID(${BLUX_ATTRIBUTES.tracking_id}) is set correctly.`);
+				return;
+			}
+			if (this.impressedElements.includes(entry.target)) return;
+			this.sendEvent(new AddSectionViewEvent({
+				section: trackingId,
+				tracking: {
+					id: trackingId,
+					type: "impression"
+				}
+			}));
+			this.impressedElements.push(entry.target);
+		});
+		const { data } = await initialize(this.api, { application_id: this.bluxApplicationId }, {
+			session_id: sessionId ?? void 0,
+			device_id: deviceId ?? void 0,
+			country_code: navigator.language.split("-")[1],
+			device_model: navigator.userAgent,
+			language_code: navigator.language.split("-")[0],
+			platform: DevicePlatform.browser,
+			os_version: navigator.userAgent,
+			sdk_version: this.sdkInfo.version,
+			sdk_type: this.sdkInfo.type,
+			timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+			blux_user_id: blux_user_id ?? void 0,
+			custom_device_id: this.customDeviceId
+		}, this.generateApiHeader({ bluxAPIKey: this.bluxAPIKey }));
+		if (data.device_id) LocalStorage.setDeviceId(data.device_id);
+		this.bluxUser$.next({
+			id: data.blux_user_id,
+			bluxAPIKey: this.bluxAPIKey,
+			applicationId: this.bluxApplicationId,
+			deviceId: data.device_id
+		});
+	}
+	setLogLevel(logLevel) {
+		Logger.setLevel(logLevel);
+	}
+	async getBluxUserWithTimeout() {
+		return await firstValueFrom(this.bluxUser$.pipe(filterNullable(), timeout(5e3), catchError((error) => {
+			return throwError(() => error.name === "TimeoutError" ? /* @__PURE__ */ new Error("Application ID is not initialized. Please initialize BluxClient.") : error);
+		})));
+	}
+	async signIn({ userId }) {
+		if (!this.isBrowser) return;
+		try {
+			if (this.bridge) {
+				this.bridge.signIn({ userId });
+				return;
+			}
+			const bluxUser = await this.getBluxUserWithTimeout();
+			const { data: { blux_user_id: bluxIdInResponse } } = await this.enqueueRequest(() => signIn(this.api, {
+				application_id: bluxUser.applicationId,
+				blux_user_id: bluxUser.id
+			}, {
+				user_id: userId,
+				device_id: bluxUser.deviceId
+			}, this.generateApiHeader(bluxUser)));
+			if (bluxIdInResponse !== bluxUser.id) {
+				Logger.debug("Blux id is changed in signIn.");
+				this.bluxUser$.next({
+					...bluxUser,
+					id: bluxIdInResponse,
+					userId
+				});
+			}
+		} catch (error) {
+			Logger.error(error, { tags: { from: "signIn" } });
+		}
+	}
+	async signOut() {
+		if (!this.isBrowser) return;
+		try {
+			if (this.bridge) {
+				this.bridge.signOut();
+				return;
+			}
+			const bluxUser = await this.getBluxUserWithTimeout();
+			const { data: { blux_user_id: bluxIdInResponse } } = await this.enqueueRequest(() => signOut(this.api, {
+				application_id: bluxUser.applicationId,
+				blux_user_id: bluxUser.id
+			}, { device_id: bluxUser.deviceId }, this.generateApiHeader(bluxUser)));
+			Logger.debug("Blux id is changed in signOut.");
+			this.bluxUser$.next({
+				...bluxUser,
+				id: bluxIdInResponse,
+				userId: void 0
+			});
+		} catch (error) {
+			Logger.error(error, { tags: { from: "signOut" } });
+		}
+	}
+	async setUserProperties({ userProperties }) {
+		if (!this.isBrowser) return;
+		try {
+			if (this.bridge) {
+				this.bridge.setUserProperties(userProperties);
+				return;
+			}
+			await new Promise((resolve, reject) => {
+				this.userPropertiesQueue$.next({
+					userProperties,
+					resolve,
+					reject
+				});
+			});
+		} catch (error) {
+			Logger.error(error, { tags: { from: "setUserProperties" } });
+		}
+	}
+	async setCustomUserProperties({ customUserProperties }) {
+		if (!this.isBrowser) return;
+		try {
+			if (this.bridge) {
+				this.bridge.setCustomUserProperties(customUserProperties);
+				return;
+			}
+			await new Promise((resolve, reject) => {
+				this.userPropertiesQueue$.next({
+					customUserProperties,
+					resolve,
+					reject
+				});
+			});
+		} catch (error) {
+			Logger.error(error, { tags: { from: "setCustomUserProperties" } });
+		}
+	}
+	sendEvent(event) {
+		if (!this.isBrowser) return;
+		try {
+			const requests = (Array.isArray(event) ? event : [event]).map((e) => ({
+				...e.request,
+				internal_event_properties: {
+					url: this.urlAndRef$.value?.url,
+					ref: this.urlAndRef$.value?.ref
+				}
+			}));
+			if (this.bridge) {
+				this.bridge.sendEvent({ requests });
+				return;
+			}
+			requests.forEach((request) => {
+				this.eventQueue$.next(request);
+			});
+		} catch (error) {
+			Logger.error(error, { tags: { from: "sendEvent" } });
+		}
+	}
+	/**
+	* 현재 표시 중인 인앱 메시지를 프로그래밍 방식으로 닫습니다.
+	*
+	* Custom HTML 인앱에서 async 핸들러 완료 후 수동으로 닫을 때 사용합니다.
+	*
+	* @example
+	* ```typescript
+	* // BluxBridge.triggerAction('share', { url: '...' }, false); // shouldDismiss: false
+	* // 핸들러에서 async 작업 완료 후:
+	* bluxClient.dismissInApp();
+	* ```
+	*/
+	dismissInApp() {
+		if (!this.isBrowser) return;
+		this.currentInappCleanup?.();
+	}
+	/**
+	* Custom HTML 인앱에서 BluxBridge.triggerAction() 호출 시 실행될 핸들러를 등록합니다.
+	* 여러 핸들러를 등록할 수 있으며, 등록 순서대로 실행됩니다.
+	*
+	* @param handler - 커스텀 액션 핸들러 함수
+	* @returns 핸들러를 제거하는 unsubscribe 함수
+	*
+	* @example
+	* ```typescript
+	* const unsubscribe = bluxClient.addInAppCustomActionHandler(async (event) => {
+	*   if (event.actionId === 'share') {
+	*     await navigator.share({ url: event.data.url as string });
+	*     // async 작업 완료 후 수동으로 닫기 (shouldDismiss: false로 호출한 경우)
+	*     bluxClient.dismissInApp();
+	*   }
+	* });
+	*
+	* // 핸들러 제거
+	* unsubscribe();
+	* ```
+	*/
+	addInAppCustomActionHandler(handler) {
+		if (!this.isBrowser) return () => {};
+		this.inAppCustomActionHandlers.add(handler);
+		return () => {
+			this.inAppCustomActionHandlers.delete(handler);
+		};
+	}
+	urlAndRef$ = new BehaviorSubject(void 0);
+	handleUrlAndRef() {
+		this.urlAndRef$.pipe(filterNullable()).subscribe(({ url, ref }) => {
+			if (ref) LocalStorage.setRef(ref);
+			LocalStorage.setUrl(url);
+		});
+		this.urlAndRef$.next({
+			url: window.location.href,
+			ref: LocalStorage.getUrl() ?? void 0
+		});
+		const handleUrlChange = () => {
+			const prevUrl = this.urlAndRef$.value?.url;
+			const currentUrl = window.location.href;
+			if (prevUrl !== currentUrl) this.urlAndRef$.next({
+				url: currentUrl,
+				ref: prevUrl ?? void 0
+			});
+		};
+		window.addEventListener("popstate", handleUrlChange);
+		history.pushState = new Proxy(history.pushState, { apply: (target, thisArg, [state, unused, url]) => {
+			target.apply(thisArg, [
+				state,
+				unused,
+				url
+			]);
+			handleUrlChange();
+		} });
+		history.replaceState = new Proxy(history.replaceState, { apply: (target, thisArg, [state, unused, url]) => {
+			target.apply(thisArg, [
+				state,
+				unused,
+				url
+			]);
+			handleUrlChange();
+		} });
+	}
+	registerImpressionTracker() {
+		const targetElements = Array.from(document.querySelectorAll(`[${BLUX_ATTRIBUTES.tracking_id}]`));
+		this.intersectionObservingElements.filter((e) => !targetElements.includes(e)).forEach((e) => {
+			this.intersectionObserver?.unobserve(e);
+		});
+		targetElements.filter((element) => !this.intersectionObservingElements.includes(element)).forEach((element) => {
+			this.intersectionObserver?.observe(element);
+		});
+		this.intersectionObservingElements = targetElements;
+	}
+	registerHitTracker() {
+		const handleDelegatedClick = (event) => {
+			if (!(event.target instanceof Element)) return;
+			const eventTarget = event.target;
+			const targetItemElement = eventTarget.closest(`[${BLUX_ATTRIBUTES.item_id}]`);
+			if (!targetItemElement) return;
+			const itemId = targetItemElement.getAttribute(BLUX_ATTRIBUTES.item_id);
+			if (!itemId) return;
+			const trackingId = eventTarget.closest(`[${BLUX_ATTRIBUTES.tracking_id}]`)?.getAttribute(BLUX_ATTRIBUTES.tracking_id);
+			if (!trackingId) {
+				Logger.warning(`Tracking ID is not found in the parent elements. Please check the tracking ID(${BLUX_ATTRIBUTES.tracking_id}) is set correctly.`);
+				return;
+			}
+			if (!this.hitElements.includes(targetItemElement)) {
+				this.sendEvent(new AddClickEvent({
+					itemId,
+					tracking: {
+						id: trackingId,
+						type: "hit"
+					}
+				}));
+				this.hitElements.push(targetItemElement);
+			}
+		};
+		document.addEventListener("click", handleDelegatedClick);
+		this.urlAndRef$.pipe(filterNullable()).subscribe(() => {
+			this.hitElements = [];
+		});
+	}
+	async getUserRec(rec) {
+		if (!this.isBrowser) return BluxClient.EMPTY_REC_RESPONSE;
+		try {
+			const bluxUser = await this.getBluxUserWithTimeout();
+			const recRequest = rec.request;
+			return (await getItemRecommendations(this.api, {
+				application_id: bluxUser.applicationId,
+				blux_user_id: bluxUser.id
+			}, {
+				call_type: recRequest.call_type,
+				limit: recRequest.limit,
+				offset: recRequest.offset
+			}, this.generateApiHeader(bluxUser))).data;
+		} catch (error) {
+			Logger.error(error, { tags: { from: "getItemRecommendations" } });
+			return {
+				item_ids: [],
+				metadata: {},
+				recommendation_id: null
+			};
+		}
+	}
+	async getItemRec(rec) {
+		if (!this.isBrowser) return BluxClient.EMPTY_REC_RESPONSE;
+		try {
+			const bluxUser = await this.getBluxUserWithTimeout();
+			const recRequest = rec.request;
+			return (await getItemRecommendations(this.api, {
+				application_id: bluxUser.applicationId,
+				blux_user_id: bluxUser.id
+			}, {
+				call_type: recRequest.call_type,
+				limit: recRequest.limit,
+				offset: recRequest.offset,
+				item_id: recRequest.item_id
+			}, this.generateApiHeader(bluxUser))).data;
+		} catch (error) {
+			Logger.error(error, { tags: { from: "getItemRecommendations" } });
+			return {
+				item_ids: [],
+				metadata: {},
+				recommendation_id: null
+			};
+		}
+	}
+	async getItemsRec(rec) {
+		if (!this.isBrowser) return BluxClient.EMPTY_REC_RESPONSE;
+		try {
+			const bluxUser = await this.getBluxUserWithTimeout();
+			const recRequest = rec.request;
+			return (await getItemRecommendations(this.api, {
+				application_id: bluxUser.applicationId,
+				blux_user_id: bluxUser.id
+			}, {
+				call_type: recRequest.call_type,
+				limit: recRequest.limit,
+				offset: recRequest.offset,
+				item_ids: recRequest.item_ids
+			}, this.generateApiHeader(bluxUser))).data;
+		} catch (error) {
+			Logger.error(error, { tags: { from: "getItemRecommendations" } });
+			return {
+				item_ids: [],
+				metadata: {},
+				recommendation_id: null
+			};
+		}
+	}
+	async getCategoryRec(rec) {
+		if (!this.isBrowser) return BluxClient.EMPTY_REC_RESPONSE;
+		try {
+			const bluxUser = await this.getBluxUserWithTimeout();
+			const recRequest = rec.request;
+			return (await getItemRecommendations(this.api, {
+				application_id: bluxUser.applicationId,
+				blux_user_id: bluxUser.id
+			}, {
+				call_type: recRequest.call_type,
+				limit: recRequest.limit,
+				offset: recRequest.offset,
+				category_id: recRequest.category_id
+			}, this.generateApiHeader(bluxUser))).data;
+		} catch (error) {
+			Logger.error(error, { tags: { from: "getItemRecommendations" } });
+			return {
+				item_ids: [],
+				metadata: {},
+				recommendation_id: null
+			};
+		}
+	}
+};
+
+//#endregion
+export { BluxClient };
+//# sourceMappingURL=BluxClient.js.map