@adstage/web-sdk 2.4.7 → 2.4.9

package/dist/index.cjs.js

@@ -33,113 +33,6 @@ var DeviceType;
     DeviceType["TABLET"] = "TABLET";
 })(DeviceType || (DeviceType = {}));
 
-/**
- * VIEWABLE 이벤트 추적 및 중복 방지 관리 클래스
- * - 메모리 기반 중복 확인
- * - 세션 스토리지 기반 영구 추적
- * - 자동 정리 기능
- * - ViewabilityTracker와 함께 사용하여 중복 viewable 이벤트 방지
- */
-class ViewableEventTracker {
-    /**
-     * 중복 viewable 이벤트 여부 확인
-     */
-    static isDuplicateViewable(adId, slotId, debug = false) {
-        const key = `${adId}_${slotId}`;
-        const now = Date.now();
-        // 디버그 모드에 따른 쿨다운 시간 결정
-        const cooldownTime = debug ?
-            ViewableEventTracker.VIEWABLE_COOLDOWN_DEBUG :
-            ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION;
-        // 메모리 기반 중복 확인 (새로고침 시 초기화됨)
-        const lastViewable = ViewableEventTracker.viewableTracker.get(key);
-        if (lastViewable && (now - lastViewable) < cooldownTime) {
-            if (debug) {
-                console.log(`Duplicate viewable blocked for ad ${adId} in slot ${slotId}. Cooldown: ${Math.round((cooldownTime - (now - lastViewable)) / 1000)}s remaining (${debug ? 'debug' : 'production'} mode)`);
-            }
-            return true;
-        }
-        // 세션 스토리지 기반 중복 확인 (새로고침 시에도 유지)
-        const sessionKey = `adstage_viewable_${key}`;
-        const sessionViewable = sessionStorage.getItem(sessionKey);
-        if (sessionViewable) {
-            const sessionTime = parseInt(sessionViewable, 10);
-            if (!isNaN(sessionTime) && (now - sessionTime) < cooldownTime) {
-                if (debug) {
-                    console.log(`Session-based duplicate viewable blocked for ad ${adId} in slot ${slotId}. Cooldown: ${Math.round((cooldownTime - (now - sessionTime)) / 1000)}s remaining (${debug ? 'debug' : 'production'} mode)`);
-                }
-                // 메모리에도 기록하여 이후 요청 최적화
-                ViewableEventTracker.viewableTracker.set(key, sessionTime);
-                return true;
-            }
-        }
-        // viewable 이벤트 시점 기록 (메모리 + 세션 스토리지)
-        ViewableEventTracker.viewableTracker.set(key, now);
-        sessionStorage.setItem(sessionKey, now.toString());
-        // 오래된 세션 스토리지 데이터 정리 (선택적)
-        ViewableEventTracker.cleanupOldViewables();
-        if (debug) {
-            console.log(`✅ New viewable recorded for ad ${adId} in slot ${slotId} (${debug ? 'debug' : 'production'} mode)`);
-        }
-        return false;
-    }
-    /**
-     * 오래된 viewable 추적 데이터 정리
-     */
-    static cleanupOldViewables() {
-        const now = Date.now();
-        // 프로덕션 쿨다운의 2배 시간이 지난 데이터 정리
-        const cleanupThreshold = ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION * 2;
-        // 세션 스토리지 정리
-        for (let i = 0; i < sessionStorage.length; i++) {
-            const key = sessionStorage.key(i);
-            if (key && key.startsWith('adstage_viewable_')) {
-                const timestamp = sessionStorage.getItem(key);
-                if (timestamp) {
-                    const time = parseInt(timestamp, 10);
-                    if (!isNaN(time) && (now - time) > cleanupThreshold) {
-                        sessionStorage.removeItem(key);
-                        i--; // 인덱스 조정
-                    }
-                }
-            }
-        }
-        // 메모리 정리
-        for (const [key, timestamp] of ViewableEventTracker.viewableTracker.entries()) {
-            if ((now - timestamp) > cleanupThreshold) {
-                ViewableEventTracker.viewableTracker.delete(key);
-            }
-        }
-    }
-    /**
-     * 모든 추적 데이터 정리 (디버그용)
-     */
-    static clear() {
-        ViewableEventTracker.viewableTracker.clear();
-        // 세션 스토리지에서도 adstage_viewable_ 키들 제거
-        const keysToRemove = [];
-        for (let i = 0; i < sessionStorage.length; i++) {
-            const key = sessionStorage.key(i);
-            if (key && key.startsWith('adstage_viewable_')) {
-                keysToRemove.push(key);
-            }
-        }
-        keysToRemove.forEach(key => sessionStorage.removeItem(key));
-    }
-    /**
-     * 특정 광고의 viewable 추적 초기화 (디버그용)
-     */
-    static clearAdViewable(adId, slotId) {
-        const key = `${adId}_${slotId}`;
-        ViewableEventTracker.viewableTracker.delete(key);
-        const sessionKey = `adstage_viewable_${key}`;
-        sessionStorage.removeItem(sessionKey);
-    }
-}
-ViewableEventTracker.viewableTracker = new Map();
-ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION = 300000; // 5분 쿨다운 (프로덕션)
-ViewableEventTracker.VIEWABLE_COOLDOWN_DEBUG = 30000; // 30초 쿨다운 (디버그)
-
 /**
  * SSR 안전한 DOM API 래퍼 클래스
  * 서버사이드 렌더링 환경에서 DOM API 접근 시 오류를 방지합니다.
@@ -579,27 +472,19 @@ class AdvertisementEventTracker {
      */
     async trackAdvertisementEvent(adId, slotId, eventType, additionalData) {
         try {
-            // VIEWABLE 이벤트의 경우 중복 확인
-            if (eventType === AdEventType.VIEWABLE) {
-                if (ViewableEventTracker.isDuplicateViewable(adId, slotId, this.debug)) {
-                    return; // 중복 viewable 이벤트이므로 추적하지 않음
-                }
+            if (this.debug) {
+                console.log(`🚀 AdvertisementEventTracker: Processing ${eventType} event for ad ${adId} in slot ${slotId}`);
             }
             // 현재 슬롯 정보 가져오기
             const slot = this.slots.get(slotId);
             // 디바이스 정보 수집
             const deviceInfo = DeviceInfoCollector.collectDeviceInfo();
             // 광고 이벤트 데이터 구성 (DTO 구조에 맞춤)
+            // 서버에서 자동 설정: orgId (API 키로부터), advertisementId, action (URL 파라미터로부터)
             const eventData = {
-                // 서버에서 자동 설정: orgId, advertisementId, action
-                // 하지만 DTO 검증을 위해 임시값 제공
-                orgId: 'temp', // 서버에서 API 키로부터 덮어씀
-                advertisementId: adId, // 서버에서 URL 파라미터로부터 덮어씀
-                action: eventType, // 서버에서 URL 파라미터로부터 덮어씀
                 // 필수 필드들
                 adType: slot?.adType || 'BANNER',
-                platform: deviceInfo.platform,
-                // 디바이스 정보는 deviceInfo 객체로 래핑
+                platform: deviceInfo.platform, // 디바이스 정보는 deviceInfo 객체로 래핑
                 deviceInfo: deviceInfo,
                 // 페이지 및 슬롯 정보
                 pageUrl: DOMUtils.getPageInfo().url,
@@ -2064,6 +1949,113 @@ class TextTransitionManager {
     }
 }
 
+/**
+ * VIEWABLE 이벤트 추적 및 중복 방지 관리 클래스
+ * - 메모리 기반 중복 확인
+ * - 세션 스토리지 기반 영구 추적
+ * - 자동 정리 기능
+ * - ViewabilityTracker와 함께 사용하여 중복 viewable 이벤트 방지
+ */
+class ViewableEventTracker {
+    /**
+     * 중복 viewable 이벤트 여부 확인
+     */
+    static isDuplicateViewable(adId, slotId, debug = false) {
+        const key = `${adId}_${slotId}`;
+        const now = Date.now();
+        // 디버그 모드에 따른 쿨다운 시간 결정
+        const cooldownTime = debug ?
+            ViewableEventTracker.VIEWABLE_COOLDOWN_DEBUG :
+            ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION;
+        // 메모리 기반 중복 확인 (새로고침 시 초기화됨)
+        const lastViewable = ViewableEventTracker.viewableTracker.get(key);
+        if (lastViewable && (now - lastViewable) < cooldownTime) {
+            if (debug) {
+                console.log(`Duplicate viewable blocked for ad ${adId} in slot ${slotId}. Cooldown: ${Math.round((cooldownTime - (now - lastViewable)) / 1000)}s remaining (${debug ? 'debug' : 'production'} mode)`);
+            }
+            return true;
+        }
+        // 세션 스토리지 기반 중복 확인 (새로고침 시에도 유지)
+        const sessionKey = `adstage_viewable_${key}`;
+        const sessionViewable = sessionStorage.getItem(sessionKey);
+        if (sessionViewable) {
+            const sessionTime = parseInt(sessionViewable, 10);
+            if (!isNaN(sessionTime) && (now - sessionTime) < cooldownTime) {
+                if (debug) {
+                    console.log(`Session-based duplicate viewable blocked for ad ${adId} in slot ${slotId}. Cooldown: ${Math.round((cooldownTime - (now - sessionTime)) / 1000)}s remaining (${debug ? 'debug' : 'production'} mode)`);
+                }
+                // 메모리에도 기록하여 이후 요청 최적화
+                ViewableEventTracker.viewableTracker.set(key, sessionTime);
+                return true;
+            }
+        }
+        // viewable 이벤트 시점 기록 (메모리 + 세션 스토리지)
+        ViewableEventTracker.viewableTracker.set(key, now);
+        sessionStorage.setItem(sessionKey, now.toString());
+        // 오래된 세션 스토리지 데이터 정리 (선택적)
+        ViewableEventTracker.cleanupOldViewables();
+        if (debug) {
+            console.log(`✅ New viewable recorded for ad ${adId} in slot ${slotId} (${debug ? 'debug' : 'production'} mode)`);
+        }
+        return false;
+    }
+    /**
+     * 오래된 viewable 추적 데이터 정리
+     */
+    static cleanupOldViewables() {
+        const now = Date.now();
+        // 프로덕션 쿨다운의 2배 시간이 지난 데이터 정리
+        const cleanupThreshold = ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION * 2;
+        // 세션 스토리지 정리
+        for (let i = 0; i < sessionStorage.length; i++) {
+            const key = sessionStorage.key(i);
+            if (key && key.startsWith('adstage_viewable_')) {
+                const timestamp = sessionStorage.getItem(key);
+                if (timestamp) {
+                    const time = parseInt(timestamp, 10);
+                    if (!isNaN(time) && (now - time) > cleanupThreshold) {
+                        sessionStorage.removeItem(key);
+                        i--; // 인덱스 조정
+                    }
+                }
+            }
+        }
+        // 메모리 정리
+        for (const [key, timestamp] of ViewableEventTracker.viewableTracker.entries()) {
+            if ((now - timestamp) > cleanupThreshold) {
+                ViewableEventTracker.viewableTracker.delete(key);
+            }
+        }
+    }
+    /**
+     * 모든 추적 데이터 정리 (디버그용)
+     */
+    static clear() {
+        ViewableEventTracker.viewableTracker.clear();
+        // 세션 스토리지에서도 adstage_viewable_ 키들 제거
+        const keysToRemove = [];
+        for (let i = 0; i < sessionStorage.length; i++) {
+            const key = sessionStorage.key(i);
+            if (key && key.startsWith('adstage_viewable_')) {
+                keysToRemove.push(key);
+            }
+        }
+        keysToRemove.forEach(key => sessionStorage.removeItem(key));
+    }
+    /**
+     * 특정 광고의 viewable 추적 초기화 (디버그용)
+     */
+    static clearAdViewable(adId, slotId) {
+        const key = `${adId}_${slotId}`;
+        ViewableEventTracker.viewableTracker.delete(key);
+        const sessionKey = `adstage_viewable_${key}`;
+        sessionStorage.removeItem(sessionKey);
+    }
+}
+ViewableEventTracker.viewableTracker = new Map();
+ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION = 300000; // 5분 쿨다운 (프로덕션)
+ViewableEventTracker.VIEWABLE_COOLDOWN_DEBUG = 30000; // 30초 쿨다운 (디버그)
+
 /**
  * AdRenderer - 광고 렌더링 전용 클래스
  * AdsModule에서 렌더링 관련 기능을 분리

package/dist/index.esm.js

@@ -31,113 +31,6 @@ var DeviceType;
     DeviceType["TABLET"] = "TABLET";
 })(DeviceType || (DeviceType = {}));
 
-/**
- * VIEWABLE 이벤트 추적 및 중복 방지 관리 클래스
- * - 메모리 기반 중복 확인
- * - 세션 스토리지 기반 영구 추적
- * - 자동 정리 기능
- * - ViewabilityTracker와 함께 사용하여 중복 viewable 이벤트 방지
- */
-class ViewableEventTracker {
-    /**
-     * 중복 viewable 이벤트 여부 확인
-     */
-    static isDuplicateViewable(adId, slotId, debug = false) {
-        const key = `${adId}_${slotId}`;
-        const now = Date.now();
-        // 디버그 모드에 따른 쿨다운 시간 결정
-        const cooldownTime = debug ?
-            ViewableEventTracker.VIEWABLE_COOLDOWN_DEBUG :
-            ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION;
-        // 메모리 기반 중복 확인 (새로고침 시 초기화됨)
-        const lastViewable = ViewableEventTracker.viewableTracker.get(key);
-        if (lastViewable && (now - lastViewable) < cooldownTime) {
-            if (debug) {
-                console.log(`Duplicate viewable blocked for ad ${adId} in slot ${slotId}. Cooldown: ${Math.round((cooldownTime - (now - lastViewable)) / 1000)}s remaining (${debug ? 'debug' : 'production'} mode)`);
-            }
-            return true;
-        }
-        // 세션 스토리지 기반 중복 확인 (새로고침 시에도 유지)
-        const sessionKey = `adstage_viewable_${key}`;
-        const sessionViewable = sessionStorage.getItem(sessionKey);
-        if (sessionViewable) {
-            const sessionTime = parseInt(sessionViewable, 10);
-            if (!isNaN(sessionTime) && (now - sessionTime) < cooldownTime) {
-                if (debug) {
-                    console.log(`Session-based duplicate viewable blocked for ad ${adId} in slot ${slotId}. Cooldown: ${Math.round((cooldownTime - (now - sessionTime)) / 1000)}s remaining (${debug ? 'debug' : 'production'} mode)`);
-                }
-                // 메모리에도 기록하여 이후 요청 최적화
-                ViewableEventTracker.viewableTracker.set(key, sessionTime);
-                return true;
-            }
-        }
-        // viewable 이벤트 시점 기록 (메모리 + 세션 스토리지)
-        ViewableEventTracker.viewableTracker.set(key, now);
-        sessionStorage.setItem(sessionKey, now.toString());
-        // 오래된 세션 스토리지 데이터 정리 (선택적)
-        ViewableEventTracker.cleanupOldViewables();
-        if (debug) {
-            console.log(`✅ New viewable recorded for ad ${adId} in slot ${slotId} (${debug ? 'debug' : 'production'} mode)`);
-        }
-        return false;
-    }
-    /**
-     * 오래된 viewable 추적 데이터 정리
-     */
-    static cleanupOldViewables() {
-        const now = Date.now();
-        // 프로덕션 쿨다운의 2배 시간이 지난 데이터 정리
-        const cleanupThreshold = ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION * 2;
-        // 세션 스토리지 정리
-        for (let i = 0; i < sessionStorage.length; i++) {
-            const key = sessionStorage.key(i);
-            if (key && key.startsWith('adstage_viewable_')) {
-                const timestamp = sessionStorage.getItem(key);
-                if (timestamp) {
-                    const time = parseInt(timestamp, 10);
-                    if (!isNaN(time) && (now - time) > cleanupThreshold) {
-                        sessionStorage.removeItem(key);
-                        i--; // 인덱스 조정
-                    }
-                }
-            }
-        }
-        // 메모리 정리
-        for (const [key, timestamp] of ViewableEventTracker.viewableTracker.entries()) {
-            if ((now - timestamp) > cleanupThreshold) {
-                ViewableEventTracker.viewableTracker.delete(key);
-            }
-        }
-    }
-    /**
-     * 모든 추적 데이터 정리 (디버그용)
-     */
-    static clear() {
-        ViewableEventTracker.viewableTracker.clear();
-        // 세션 스토리지에서도 adstage_viewable_ 키들 제거
-        const keysToRemove = [];
-        for (let i = 0; i < sessionStorage.length; i++) {
-            const key = sessionStorage.key(i);
-            if (key && key.startsWith('adstage_viewable_')) {
-                keysToRemove.push(key);
-            }
-        }
-        keysToRemove.forEach(key => sessionStorage.removeItem(key));
-    }
-    /**
-     * 특정 광고의 viewable 추적 초기화 (디버그용)
-     */
-    static clearAdViewable(adId, slotId) {
-        const key = `${adId}_${slotId}`;
-        ViewableEventTracker.viewableTracker.delete(key);
-        const sessionKey = `adstage_viewable_${key}`;
-        sessionStorage.removeItem(sessionKey);
-    }
-}
-ViewableEventTracker.viewableTracker = new Map();
-ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION = 300000; // 5분 쿨다운 (프로덕션)
-ViewableEventTracker.VIEWABLE_COOLDOWN_DEBUG = 30000; // 30초 쿨다운 (디버그)
-
 /**
  * SSR 안전한 DOM API 래퍼 클래스
  * 서버사이드 렌더링 환경에서 DOM API 접근 시 오류를 방지합니다.
@@ -577,27 +470,19 @@ class AdvertisementEventTracker {
      */
     async trackAdvertisementEvent(adId, slotId, eventType, additionalData) {
         try {
-            // VIEWABLE 이벤트의 경우 중복 확인
-            if (eventType === AdEventType.VIEWABLE) {
-                if (ViewableEventTracker.isDuplicateViewable(adId, slotId, this.debug)) {
-                    return; // 중복 viewable 이벤트이므로 추적하지 않음
-                }
+            if (this.debug) {
+                console.log(`🚀 AdvertisementEventTracker: Processing ${eventType} event for ad ${adId} in slot ${slotId}`);
             }
             // 현재 슬롯 정보 가져오기
             const slot = this.slots.get(slotId);
             // 디바이스 정보 수집
             const deviceInfo = DeviceInfoCollector.collectDeviceInfo();
             // 광고 이벤트 데이터 구성 (DTO 구조에 맞춤)
+            // 서버에서 자동 설정: orgId (API 키로부터), advertisementId, action (URL 파라미터로부터)
             const eventData = {
-                // 서버에서 자동 설정: orgId, advertisementId, action
-                // 하지만 DTO 검증을 위해 임시값 제공
-                orgId: 'temp', // 서버에서 API 키로부터 덮어씀
-                advertisementId: adId, // 서버에서 URL 파라미터로부터 덮어씀
-                action: eventType, // 서버에서 URL 파라미터로부터 덮어씀
                 // 필수 필드들
                 adType: slot?.adType || 'BANNER',
-                platform: deviceInfo.platform,
-                // 디바이스 정보는 deviceInfo 객체로 래핑
+                platform: deviceInfo.platform, // 디바이스 정보는 deviceInfo 객체로 래핑
                 deviceInfo: deviceInfo,
                 // 페이지 및 슬롯 정보
                 pageUrl: DOMUtils.getPageInfo().url,
@@ -2062,6 +1947,113 @@ class TextTransitionManager {
     }
 }
 
+/**
+ * VIEWABLE 이벤트 추적 및 중복 방지 관리 클래스
+ * - 메모리 기반 중복 확인
+ * - 세션 스토리지 기반 영구 추적
+ * - 자동 정리 기능
+ * - ViewabilityTracker와 함께 사용하여 중복 viewable 이벤트 방지
+ */
+class ViewableEventTracker {
+    /**
+     * 중복 viewable 이벤트 여부 확인
+     */
+    static isDuplicateViewable(adId, slotId, debug = false) {
+        const key = `${adId}_${slotId}`;
+        const now = Date.now();
+        // 디버그 모드에 따른 쿨다운 시간 결정
+        const cooldownTime = debug ?
+            ViewableEventTracker.VIEWABLE_COOLDOWN_DEBUG :
+            ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION;
+        // 메모리 기반 중복 확인 (새로고침 시 초기화됨)
+        const lastViewable = ViewableEventTracker.viewableTracker.get(key);
+        if (lastViewable && (now - lastViewable) < cooldownTime) {
+            if (debug) {
+                console.log(`Duplicate viewable blocked for ad ${adId} in slot ${slotId}. Cooldown: ${Math.round((cooldownTime - (now - lastViewable)) / 1000)}s remaining (${debug ? 'debug' : 'production'} mode)`);
+            }
+            return true;
+        }
+        // 세션 스토리지 기반 중복 확인 (새로고침 시에도 유지)
+        const sessionKey = `adstage_viewable_${key}`;
+        const sessionViewable = sessionStorage.getItem(sessionKey);
+        if (sessionViewable) {
+            const sessionTime = parseInt(sessionViewable, 10);
+            if (!isNaN(sessionTime) && (now - sessionTime) < cooldownTime) {
+                if (debug) {
+                    console.log(`Session-based duplicate viewable blocked for ad ${adId} in slot ${slotId}. Cooldown: ${Math.round((cooldownTime - (now - sessionTime)) / 1000)}s remaining (${debug ? 'debug' : 'production'} mode)`);
+                }
+                // 메모리에도 기록하여 이후 요청 최적화
+                ViewableEventTracker.viewableTracker.set(key, sessionTime);
+                return true;
+            }
+        }
+        // viewable 이벤트 시점 기록 (메모리 + 세션 스토리지)
+        ViewableEventTracker.viewableTracker.set(key, now);
+        sessionStorage.setItem(sessionKey, now.toString());
+        // 오래된 세션 스토리지 데이터 정리 (선택적)
+        ViewableEventTracker.cleanupOldViewables();
+        if (debug) {
+            console.log(`✅ New viewable recorded for ad ${adId} in slot ${slotId} (${debug ? 'debug' : 'production'} mode)`);
+        }
+        return false;
+    }
+    /**
+     * 오래된 viewable 추적 데이터 정리
+     */
+    static cleanupOldViewables() {
+        const now = Date.now();
+        // 프로덕션 쿨다운의 2배 시간이 지난 데이터 정리
+        const cleanupThreshold = ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION * 2;
+        // 세션 스토리지 정리
+        for (let i = 0; i < sessionStorage.length; i++) {
+            const key = sessionStorage.key(i);
+            if (key && key.startsWith('adstage_viewable_')) {
+                const timestamp = sessionStorage.getItem(key);
+                if (timestamp) {
+                    const time = parseInt(timestamp, 10);
+                    if (!isNaN(time) && (now - time) > cleanupThreshold) {
+                        sessionStorage.removeItem(key);
+                        i--; // 인덱스 조정
+                    }
+                }
+            }
+        }
+        // 메모리 정리
+        for (const [key, timestamp] of ViewableEventTracker.viewableTracker.entries()) {
+            if ((now - timestamp) > cleanupThreshold) {
+                ViewableEventTracker.viewableTracker.delete(key);
+            }
+        }
+    }
+    /**
+     * 모든 추적 데이터 정리 (디버그용)
+     */
+    static clear() {
+        ViewableEventTracker.viewableTracker.clear();
+        // 세션 스토리지에서도 adstage_viewable_ 키들 제거
+        const keysToRemove = [];
+        for (let i = 0; i < sessionStorage.length; i++) {
+            const key = sessionStorage.key(i);
+            if (key && key.startsWith('adstage_viewable_')) {
+                keysToRemove.push(key);
+            }
+        }
+        keysToRemove.forEach(key => sessionStorage.removeItem(key));
+    }
+    /**
+     * 특정 광고의 viewable 추적 초기화 (디버그용)
+     */
+    static clearAdViewable(adId, slotId) {
+        const key = `${adId}_${slotId}`;
+        ViewableEventTracker.viewableTracker.delete(key);
+        const sessionKey = `adstage_viewable_${key}`;
+        sessionStorage.removeItem(sessionKey);
+    }
+}
+ViewableEventTracker.viewableTracker = new Map();
+ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION = 300000; // 5분 쿨다운 (프로덕션)
+ViewableEventTracker.VIEWABLE_COOLDOWN_DEBUG = 30000; // 30초 쿨다운 (디버그)
+
 /**
  * AdRenderer - 광고 렌더링 전용 클래스
  * AdsModule에서 렌더링 관련 기능을 분리

package/dist/index.standalone.js

@@ -28,113 +28,6 @@ var DeviceType;
     DeviceType["TABLET"] = "TABLET";
 })(DeviceType || (DeviceType = {}));
 
-/**
- * VIEWABLE 이벤트 추적 및 중복 방지 관리 클래스
- * - 메모리 기반 중복 확인
- * - 세션 스토리지 기반 영구 추적
- * - 자동 정리 기능
- * - ViewabilityTracker와 함께 사용하여 중복 viewable 이벤트 방지
- */
-class ViewableEventTracker {
-    /**
-     * 중복 viewable 이벤트 여부 확인
-     */
-    static isDuplicateViewable(adId, slotId, debug = false) {
-        const key = `${adId}_${slotId}`;
-        const now = Date.now();
-        // 디버그 모드에 따른 쿨다운 시간 결정
-        const cooldownTime = debug ?
-            ViewableEventTracker.VIEWABLE_COOLDOWN_DEBUG :
-            ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION;
-        // 메모리 기반 중복 확인 (새로고침 시 초기화됨)
-        const lastViewable = ViewableEventTracker.viewableTracker.get(key);
-        if (lastViewable && (now - lastViewable) < cooldownTime) {
-            if (debug) {
-                console.log(`Duplicate viewable blocked for ad ${adId} in slot ${slotId}. Cooldown: ${Math.round((cooldownTime - (now - lastViewable)) / 1000)}s remaining (${debug ? 'debug' : 'production'} mode)`);
-            }
-            return true;
-        }
-        // 세션 스토리지 기반 중복 확인 (새로고침 시에도 유지)
-        const sessionKey = `adstage_viewable_${key}`;
-        const sessionViewable = sessionStorage.getItem(sessionKey);
-        if (sessionViewable) {
-            const sessionTime = parseInt(sessionViewable, 10);
-            if (!isNaN(sessionTime) && (now - sessionTime) < cooldownTime) {
-                if (debug) {
-                    console.log(`Session-based duplicate viewable blocked for ad ${adId} in slot ${slotId}. Cooldown: ${Math.round((cooldownTime - (now - sessionTime)) / 1000)}s remaining (${debug ? 'debug' : 'production'} mode)`);
-                }
-                // 메모리에도 기록하여 이후 요청 최적화
-                ViewableEventTracker.viewableTracker.set(key, sessionTime);
-                return true;
-            }
-        }
-        // viewable 이벤트 시점 기록 (메모리 + 세션 스토리지)
-        ViewableEventTracker.viewableTracker.set(key, now);
-        sessionStorage.setItem(sessionKey, now.toString());
-        // 오래된 세션 스토리지 데이터 정리 (선택적)
-        ViewableEventTracker.cleanupOldViewables();
-        if (debug) {
-            console.log(`✅ New viewable recorded for ad ${adId} in slot ${slotId} (${debug ? 'debug' : 'production'} mode)`);
-        }
-        return false;
-    }
-    /**
-     * 오래된 viewable 추적 데이터 정리
-     */
-    static cleanupOldViewables() {
-        const now = Date.now();
-        // 프로덕션 쿨다운의 2배 시간이 지난 데이터 정리
-        const cleanupThreshold = ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION * 2;
-        // 세션 스토리지 정리
-        for (let i = 0; i < sessionStorage.length; i++) {
-            const key = sessionStorage.key(i);
-            if (key && key.startsWith('adstage_viewable_')) {
-                const timestamp = sessionStorage.getItem(key);
-                if (timestamp) {
-                    const time = parseInt(timestamp, 10);
-                    if (!isNaN(time) && (now - time) > cleanupThreshold) {
-                        sessionStorage.removeItem(key);
-                        i--; // 인덱스 조정
-                    }
-                }
-            }
-        }
-        // 메모리 정리
-        for (const [key, timestamp] of ViewableEventTracker.viewableTracker.entries()) {
-            if ((now - timestamp) > cleanupThreshold) {
-                ViewableEventTracker.viewableTracker.delete(key);
-            }
-        }
-    }
-    /**
-     * 모든 추적 데이터 정리 (디버그용)
-     */
-    static clear() {
-        ViewableEventTracker.viewableTracker.clear();
-        // 세션 스토리지에서도 adstage_viewable_ 키들 제거
-        const keysToRemove = [];
-        for (let i = 0; i < sessionStorage.length; i++) {
-            const key = sessionStorage.key(i);
-            if (key && key.startsWith('adstage_viewable_')) {
-                keysToRemove.push(key);
-            }
-        }
-        keysToRemove.forEach(key => sessionStorage.removeItem(key));
-    }
-    /**
-     * 특정 광고의 viewable 추적 초기화 (디버그용)
-     */
-    static clearAdViewable(adId, slotId) {
-        const key = `${adId}_${slotId}`;
-        ViewableEventTracker.viewableTracker.delete(key);
-        const sessionKey = `adstage_viewable_${key}`;
-        sessionStorage.removeItem(sessionKey);
-    }
-}
-ViewableEventTracker.viewableTracker = new Map();
-ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION = 300000; // 5분 쿨다운 (프로덕션)
-ViewableEventTracker.VIEWABLE_COOLDOWN_DEBUG = 30000; // 30초 쿨다운 (디버그)
-
 /**
  * SSR 안전한 DOM API 래퍼 클래스
  * 서버사이드 렌더링 환경에서 DOM API 접근 시 오류를 방지합니다.
@@ -574,27 +467,19 @@ class AdvertisementEventTracker {
      */
     async trackAdvertisementEvent(adId, slotId, eventType, additionalData) {
         try {
-            // VIEWABLE 이벤트의 경우 중복 확인
-            if (eventType === AdEventType.VIEWABLE) {
-                if (ViewableEventTracker.isDuplicateViewable(adId, slotId, this.debug)) {
-                    return; // 중복 viewable 이벤트이므로 추적하지 않음
-                }
+            if (this.debug) {
+                console.log(`🚀 AdvertisementEventTracker: Processing ${eventType} event for ad ${adId} in slot ${slotId}`);
             }
             // 현재 슬롯 정보 가져오기
             const slot = this.slots.get(slotId);
             // 디바이스 정보 수집
             const deviceInfo = DeviceInfoCollector.collectDeviceInfo();
             // 광고 이벤트 데이터 구성 (DTO 구조에 맞춤)
+            // 서버에서 자동 설정: orgId (API 키로부터), advertisementId, action (URL 파라미터로부터)
             const eventData = {
-                // 서버에서 자동 설정: orgId, advertisementId, action
-                // 하지만 DTO 검증을 위해 임시값 제공
-                orgId: 'temp', // 서버에서 API 키로부터 덮어씀
-                advertisementId: adId, // 서버에서 URL 파라미터로부터 덮어씀
-                action: eventType, // 서버에서 URL 파라미터로부터 덮어씀
                 // 필수 필드들
                 adType: slot?.adType || 'BANNER',
-                platform: deviceInfo.platform,
-                // 디바이스 정보는 deviceInfo 객체로 래핑
+                platform: deviceInfo.platform, // 디바이스 정보는 deviceInfo 객체로 래핑
                 deviceInfo: deviceInfo,
                 // 페이지 및 슬롯 정보
                 pageUrl: DOMUtils.getPageInfo().url,
@@ -2059,6 +1944,113 @@ class TextTransitionManager {
     }
 }
 
+/**
+ * VIEWABLE 이벤트 추적 및 중복 방지 관리 클래스
+ * - 메모리 기반 중복 확인
+ * - 세션 스토리지 기반 영구 추적
+ * - 자동 정리 기능
+ * - ViewabilityTracker와 함께 사용하여 중복 viewable 이벤트 방지
+ */
+class ViewableEventTracker {
+    /**
+     * 중복 viewable 이벤트 여부 확인
+     */
+    static isDuplicateViewable(adId, slotId, debug = false) {
+        const key = `${adId}_${slotId}`;
+        const now = Date.now();
+        // 디버그 모드에 따른 쿨다운 시간 결정
+        const cooldownTime = debug ?
+            ViewableEventTracker.VIEWABLE_COOLDOWN_DEBUG :
+            ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION;
+        // 메모리 기반 중복 확인 (새로고침 시 초기화됨)
+        const lastViewable = ViewableEventTracker.viewableTracker.get(key);
+        if (lastViewable && (now - lastViewable) < cooldownTime) {
+            if (debug) {
+                console.log(`Duplicate viewable blocked for ad ${adId} in slot ${slotId}. Cooldown: ${Math.round((cooldownTime - (now - lastViewable)) / 1000)}s remaining (${debug ? 'debug' : 'production'} mode)`);
+            }
+            return true;
+        }
+        // 세션 스토리지 기반 중복 확인 (새로고침 시에도 유지)
+        const sessionKey = `adstage_viewable_${key}`;
+        const sessionViewable = sessionStorage.getItem(sessionKey);
+        if (sessionViewable) {
+            const sessionTime = parseInt(sessionViewable, 10);
+            if (!isNaN(sessionTime) && (now - sessionTime) < cooldownTime) {
+                if (debug) {
+                    console.log(`Session-based duplicate viewable blocked for ad ${adId} in slot ${slotId}. Cooldown: ${Math.round((cooldownTime - (now - sessionTime)) / 1000)}s remaining (${debug ? 'debug' : 'production'} mode)`);
+                }
+                // 메모리에도 기록하여 이후 요청 최적화
+                ViewableEventTracker.viewableTracker.set(key, sessionTime);
+                return true;
+            }
+        }
+        // viewable 이벤트 시점 기록 (메모리 + 세션 스토리지)
+        ViewableEventTracker.viewableTracker.set(key, now);
+        sessionStorage.setItem(sessionKey, now.toString());
+        // 오래된 세션 스토리지 데이터 정리 (선택적)
+        ViewableEventTracker.cleanupOldViewables();
+        if (debug) {
+            console.log(`✅ New viewable recorded for ad ${adId} in slot ${slotId} (${debug ? 'debug' : 'production'} mode)`);
+        }
+        return false;
+    }
+    /**
+     * 오래된 viewable 추적 데이터 정리
+     */
+    static cleanupOldViewables() {
+        const now = Date.now();
+        // 프로덕션 쿨다운의 2배 시간이 지난 데이터 정리
+        const cleanupThreshold = ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION * 2;
+        // 세션 스토리지 정리
+        for (let i = 0; i < sessionStorage.length; i++) {
+            const key = sessionStorage.key(i);
+            if (key && key.startsWith('adstage_viewable_')) {
+                const timestamp = sessionStorage.getItem(key);
+                if (timestamp) {
+                    const time = parseInt(timestamp, 10);
+                    if (!isNaN(time) && (now - time) > cleanupThreshold) {
+                        sessionStorage.removeItem(key);
+                        i--; // 인덱스 조정
+                    }
+                }
+            }
+        }
+        // 메모리 정리
+        for (const [key, timestamp] of ViewableEventTracker.viewableTracker.entries()) {
+            if ((now - timestamp) > cleanupThreshold) {
+                ViewableEventTracker.viewableTracker.delete(key);
+            }
+        }
+    }
+    /**
+     * 모든 추적 데이터 정리 (디버그용)
+     */
+    static clear() {
+        ViewableEventTracker.viewableTracker.clear();
+        // 세션 스토리지에서도 adstage_viewable_ 키들 제거
+        const keysToRemove = [];
+        for (let i = 0; i < sessionStorage.length; i++) {
+            const key = sessionStorage.key(i);
+            if (key && key.startsWith('adstage_viewable_')) {
+                keysToRemove.push(key);
+            }
+        }
+        keysToRemove.forEach(key => sessionStorage.removeItem(key));
+    }
+    /**
+     * 특정 광고의 viewable 추적 초기화 (디버그용)
+     */
+    static clearAdViewable(adId, slotId) {
+        const key = `${adId}_${slotId}`;
+        ViewableEventTracker.viewableTracker.delete(key);
+        const sessionKey = `adstage_viewable_${key}`;
+        sessionStorage.removeItem(sessionKey);
+    }
+}
+ViewableEventTracker.viewableTracker = new Map();
+ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION = 300000; // 5분 쿨다운 (프로덕션)
+ViewableEventTracker.VIEWABLE_COOLDOWN_DEBUG = 30000; // 30초 쿨다운 (디버그)
+
 /**
  * AdRenderer - 광고 렌더링 전용 클래스
  * AdsModule에서 렌더링 관련 기능을 분리

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adstage/web-sdk",
-  "version": "2.4.7",
+  "version": "2.4.9",
   "description": "AdStage Web SDK - Production-ready marketing platform SDK with React Provider support for seamless integration",
   "type": "module",
   "main": "dist/index.cjs.js",

package/src/managers/ads/advertisement-event-tracker.ts

@@ -40,11 +40,8 @@ export class AdvertisementEventTracker {
     }
   ): Promise<void> {
     try {
-      // VIEWABLE 이벤트의 경우 중복 확인
-      if (eventType === AdEventType.VIEWABLE) {
-        if (ViewableEventTracker.isDuplicateViewable(adId, slotId, this.debug)) {
-          return; // 중복 viewable 이벤트이므로 추적하지 않음
-        }
+      if (this.debug) {
+        console.log(`🚀 AdvertisementEventTracker: Processing ${eventType} event for ad ${adId} in slot ${slotId}`);
       }
       
       // 현재 슬롯 정보 가져오기
@@ -53,19 +50,12 @@ export class AdvertisementEventTracker {
       // 디바이스 정보 수집
       const deviceInfo = DeviceInfoCollector.collectDeviceInfo();
 
-      // 광고 이벤트 데이터 구성 (DTO 구조에 맞춤)
-      const eventData = {
-        // 서버에서 자동 설정: orgId, advertisementId, action
-        // 하지만 DTO 검증을 위해 임시값 제공
-        orgId: 'temp', // 서버에서 API 키로부터 덮어씀
-        advertisementId: adId, // 서버에서 URL 파라미터로부터 덮어씀
-        action: eventType, // 서버에서 URL 파라미터로부터 덮어씀
-        
-        // 필수 필드들
-        adType: slot?.adType || 'BANNER',
-        platform: deviceInfo.platform,
-        
-        // 디바이스 정보는 deviceInfo 객체로 래핑
+        // 광고 이벤트 데이터 구성 (DTO 구조에 맞춤)
+        // 서버에서 자동 설정: orgId (API 키로부터), advertisementId, action (URL 파라미터로부터)
+        const eventData = {
+          // 필수 필드들
+          adType: slot?.adType || 'BANNER',
+          platform: deviceInfo.platform,        // 디바이스 정보는 deviceInfo 객체로 래핑
         deviceInfo: deviceInfo,
         
         // 페이지 및 슬롯 정보