@smoud/playable-sdk 1.0.3 → 1.0.5

package/dist/{index.d.mts → esm/core.d.ts}

@@ -1,5 +1,4 @@
-type EventName = 'init' | 'boot' | 'ready' | 'start' | 'interaction' | 'resize' | 'pause' | 'resume' | 'volume' | 'retry' | 'finish' | 'install';
-
+import { EventName } from './events';
 type InitCallbackType = (maxWidth: number, maxHeight: number) => void;
 /**
  * Main SDK class providing playable ad functionality and state management.
@@ -172,5 +171,4 @@ declare class sdk {
      */
     static off(event: EventName, fn?: Function, context?: any): void;
 }
-
-export { sdk as default, sdk };
+export { sdk };

package/dist/esm/core.js

@@ -0,0 +1,517 @@
+import { emitEvent, offEvent, onEvent } from './events';
+import { isDapi, isMraid, isNucleo, ensureProtocol, isGoogle, isTapjoy, isMintegral, isFacebook, isTikTok } from './protocols';
+const destinationUrl = /android/i.test(navigator.userAgent) ? GOOGLE_PLAY_URL : APP_STORE_URL;
+let isSDKInitialized = false;
+let isProtocolInitialized = false;
+let isForcePaused = false;
+let isInstallClicked = false;
+let initCallback = () => { };
+function bootAd() {
+    if (sdk.isReady)
+        return;
+    emitEvent('boot');
+    document.body.oncontextmenu = function () {
+        return false;
+    };
+    initCallback(sdk.maxWidth, sdk.maxHeight);
+    emitEvent('ready');
+    sdk.isReady = true;
+}
+function changeVolume(value) {
+    emitEvent('volume', value);
+}
+function handlePause() {
+    changeVolume(0);
+    sdk.isPaused = true;
+    emitEvent('pause');
+}
+function handleResume() {
+    if (isForcePaused)
+        return;
+    changeVolume(sdk.volume);
+    sdk.isPaused = false;
+    emitEvent('resume');
+}
+function mraidIsViewable(viewable) {
+    if ('mraid' !== AD_PROTOCOL)
+        return;
+    if (viewable) {
+        if (sdk.isReady) {
+            handleResume();
+        }
+        else {
+            if (AD_NETWORK == 'ironsource') {
+                const maxSize = mraid.getMaxSize();
+                sdk.maxWidth = Math.floor(maxSize.width);
+                sdk.maxHeight = Math.floor(maxSize.height);
+            }
+            bootAd();
+        }
+    }
+    else {
+        handlePause();
+    }
+}
+function dapiIsViewable(event) {
+    if ('dapi' !== AD_PROTOCOL)
+        return;
+    if (event.isViewable) {
+        if (sdk.isReady) {
+            handleResume();
+        }
+        else {
+            var screenSize = dapi.getScreenSize();
+            screenSize.width = Math.floor(screenSize.width);
+            screenSize.height = Math.floor(screenSize.height);
+            bootAd();
+        }
+    }
+    else {
+        handlePause();
+    }
+}
+function fireResizeEvent(width, height) {
+    handleResize(width, height);
+}
+function startMraidProtocol() {
+    if ('mraid' !== AD_PROTOCOL)
+        return;
+    if (!isProtocolInitialized) {
+        mraid.removeEventListener('ready', startMraidProtocol);
+        mraid.addEventListener('viewableChange', function () {
+            var isViewable = mraid.isViewable();
+            mraidIsViewable(isViewable);
+        });
+        if (mraid.isViewable() || AD_NETWORK == 'adcolony') {
+            mraidIsViewable(true);
+        }
+        mraid.addEventListener('audioVolumeChange', function (newVolume) {
+            if (newVolume !== null) {
+                if (newVolume > 0) {
+                    changeVolume(sdk.volume);
+                }
+                else {
+                    changeVolume(0);
+                }
+            }
+        });
+        mraid.addEventListener('error', function (t, e) {
+            console.log('mraid error: ' + t + '   action: ' + e);
+        });
+        mraid.addEventListener('sizeChange', function () {
+            var maxSize = mraid.getMaxSize();
+            fireResizeEvent(maxSize.width, maxSize.height);
+        });
+        // mraid.addEventListener('stateChange', function (t) {});
+        isProtocolInitialized = true;
+    }
+}
+function startDapiProtocol() {
+    if ('dapi' !== AD_PROTOCOL)
+        return;
+    if (!isProtocolInitialized) {
+        dapi.removeEventListener('ready', startDapiProtocol);
+        dapi.getAudioVolume();
+        dapi.addEventListener('audioVolumeChange', function (volume) {
+            var isAudioEnabled = !!volume;
+            if (isAudioEnabled) {
+                changeVolume(sdk.volume);
+            }
+            else {
+                changeVolume(0);
+            }
+        });
+        dapi.addEventListener('adResized', function (event) {
+            var maxSize = dapi.getScreenSize();
+            fireResizeEvent(event.width || maxSize.width, event.height || maxSize.height);
+        });
+        if (dapi.isViewable()) {
+            dapiIsViewable({ isViewable: true });
+        }
+        dapi.addEventListener('viewableChange', dapiIsViewable);
+        isProtocolInitialized = true;
+    }
+}
+function startDefaultProtocol() {
+    if ('none' !== AD_PROTOCOL)
+        return;
+    if (!isProtocolInitialized) {
+        if ('mintegral' === AD_NETWORK) {
+            window.mintGameStart = function () {
+                handleResume();
+                handleResize(sdk.maxWidth, sdk.maxHeight);
+            };
+            window.mintGameClose = function () {
+                handlePause();
+            };
+        }
+        document.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'visible') {
+                handleResume();
+            }
+            else {
+                handlePause();
+            }
+        });
+        if (document.readyState === 'complete') {
+            bootAd();
+        }
+        else {
+            window.addEventListener('load', () => {
+                bootAd();
+            });
+        }
+        window.addEventListener('resize', function () {
+            handleResize();
+        });
+        if ('tapjoy' === AD_NETWORK && isTapjoy()) {
+            var tapjoyApi = {
+                skipAd: function () {
+                    try {
+                        sdk.finish();
+                    }
+                    catch (e) {
+                        console.warn('Could not skip ad! | ' + e);
+                    }
+                }
+            };
+            window.TJ_API.setPlayableAPI && window.TJ_API.setPlayableAPI(tapjoyApi);
+        }
+        isProtocolInitialized = true;
+    }
+}
+function finishTapjoy() {
+    window.TJ_API.objectiveComplete && window.TJ_API.objectiveComplete();
+    window.TJ_API.playableFinished && window.TJ_API.playableFinished();
+    window.TJ_API.gameplayFinished && window.TJ_API.gameplayFinished();
+}
+function handleResize(width, height) {
+    sdk.maxWidth = Math.floor(width || window.innerWidth);
+    sdk.maxHeight = Math.floor(height || window.innerHeight);
+    sdk.isLandscape = sdk.maxWidth > sdk.maxHeight;
+    emitEvent('resize', sdk.maxWidth, sdk.maxHeight);
+}
+let isListeningToTouchEvents = false;
+let isTouchEventRegistered = false;
+function onUserInteraction(event) {
+    if (typeof TouchEvent !== 'undefined' && event instanceof TouchEvent) {
+        isListeningToTouchEvents = true;
+    }
+    if (isListeningToTouchEvents && event instanceof MouseEvent)
+        return;
+    sdk.interactions += 1;
+    emitEvent('interaction', sdk.interactions);
+}
+function registerTouchHandlers() {
+    if (!isTouchEventRegistered) {
+        document.addEventListener('mousedown', onUserInteraction);
+        document.addEventListener('touchstart', onUserInteraction);
+        isTouchEventRegistered = true;
+    }
+}
+/**
+ * Main SDK class providing playable ad functionality and state management.
+ * Handles initialization, lifecycle events, and interactions across different ad networks.
+ */
+class sdk {
+    /**
+     * Initializes the SDK and sets up protocol-specific handlers.
+     * This must be called as earlier as possible.
+     *
+     * @param callback Optional function called when ad container is ready
+     * @example
+     * // Basic initialization
+     * sdk.init();
+     *
+     * // Initialization with callback
+     * sdk.init((width, height) => {
+     *   new App(width, height)
+     * });
+     *
+     * @fires init When initialization starts
+     * @fires boot When the ad begins booting
+     * @fires ready When Ad Network is ready and playable ad can be initialized
+     */
+    static init(callback) {
+        if (isSDKInitialized)
+            return;
+        ensureProtocol();
+        if (callback)
+            initCallback = callback;
+        if ('mraid' === AD_PROTOCOL && isMraid()) {
+            if (mraid.getState() !== 'ready' && 'adcolony' !== AD_NETWORK) {
+                mraid.addEventListener('ready', startMraidProtocol);
+            }
+            else {
+                startMraidProtocol();
+            }
+        }
+        else if ('dapi' === AD_PROTOCOL && isDapi()) {
+            window.addEventListener('load', function () {
+                dapi.isReady() ? startDapiProtocol() : dapi.addEventListener('ready', startDapiProtocol);
+            });
+        }
+        else {
+            startDefaultProtocol();
+        }
+        emitEvent('init');
+        isSDKInitialized = true;
+    }
+    /**
+     * Starts the playable ad experience.
+     * Should be called after all resources are loaded and first frame is rendered.
+     *
+     * @example
+     * // Call just after all resources are preloaded and first frame is rendered
+     * sdk.start();
+     *
+     * @fires start When the playable ad starts
+     * @fires resize When the ad container is initially sized
+     */
+    static start() {
+        if (sdk.isStarted)
+            return;
+        sdk.isStarted = true;
+        emitEvent('start');
+        registerTouchHandlers();
+        if ('mintegral' === AD_NETWORK && isMintegral()) {
+            sdk.resize();
+            handlePause();
+            window.gameReady && window.gameReady();
+        }
+        else {
+            if ('tapjoy' === AD_NETWORK && isTapjoy()) {
+                window.TJ_API.setPlayableBuild({
+                    orientation: this.isLandscape ? 'landscape' : 'portrait',
+                    buildID: BUILD_HASH
+                });
+            }
+            sdk.resize();
+        }
+    }
+    /**
+     * Marks the playable ad as finished.
+     * This triggers network-specific completion handlers.
+     *
+     * @example
+     * // Call when game/experience is complete
+     * sdk.finish();
+     *
+     * @fires finish When the playable ad is marked as finished
+     */
+    static finish() {
+        sdk.isFinished = true;
+        if ('tapjoy' === AD_NETWORK && isTapjoy()) {
+            finishTapjoy();
+        }
+        else if ('mintegral' === AD_NETWORK && isMintegral()) {
+            window.gameEnd && window.gameEnd();
+        }
+        else if ('vungle' === AD_NETWORK) {
+            parent.postMessage('complete', '*');
+        }
+        emitEvent('finish');
+    }
+    /**
+     * Triggers a retry/restart of the playable ad.
+     * Behavior varies by ad network.
+     *
+     * @example
+     * // Allow user to try again
+     * retryButton.onclick = () => sdk.retry();
+     *
+     * @fires retry When a retry is triggered
+     */
+    static retry() {
+        if ('mintegral' === AD_NETWORK && isMintegral()) {
+            window.gameRetry && window.gameRetry();
+        }
+        else if ('nucleo' === AD_PROTOCOL && isNucleo()) {
+            NUC.trigger.tryAgain();
+        }
+        emitEvent('retry');
+    }
+    /**
+     * Triggers the install/download action for the advertised app.
+     * Handles different store opening methods across ad networks.
+     *
+     * @example
+     * // Call when user wants to install
+     * installButton.onclick = () => sdk.install();
+     *
+     * @fires finish If the ad hasn't been marked as finished
+     * @fires install When the install action is triggered
+     */
+    static install() {
+        if (!sdk.isFinished) {
+            sdk.isFinished = true;
+            let timeout = 0;
+            if ('tapjoy' === AD_NETWORK && isTapjoy()) {
+                finishTapjoy();
+                timeout = 300;
+            }
+            emitEvent('finish');
+            setTimeout(function () {
+                sdk.install();
+            }, timeout);
+            return;
+        }
+        if (isInstallClicked)
+            return;
+        isInstallClicked = true;
+        setTimeout(function () {
+            isInstallClicked = false;
+        }, 500);
+        emitEvent('install');
+        if ('mraid' === AD_PROTOCOL && isMraid()) {
+            mraid.open(destinationUrl);
+        }
+        else if ('dapi' === AD_PROTOCOL && isDapi()) {
+            dapi.openStoreUrl();
+        }
+        else if ('nucleo' === AD_PROTOCOL && isNucleo()) {
+            NUC.trigger.convert(destinationUrl);
+        }
+        else if ('facebook' == AD_NETWORK && isFacebook()) {
+            FbPlayableAd.onCTAClick();
+        }
+        else if ('vungle' == AD_NETWORK) {
+            parent.postMessage('download', '*');
+        }
+        else if ('google' == AD_NETWORK && isGoogle()) {
+            ExitApi.exit();
+        }
+        else if ('mintegral' === AD_NETWORK && isMintegral()) {
+            window.install && window.install();
+        }
+        else if ('tapjoy' === AD_NETWORK && isTapjoy()) {
+            window.TJ_API.click();
+        }
+        else if ('tiktok' === AD_NETWORK && isTikTok()) {
+            window.openAppStore();
+        }
+        else {
+            window.open(destinationUrl);
+        }
+    }
+    /**
+     * Trigger force resize event
+     * Useful when container size changes need to be manually propagated.
+     *
+     * @example
+     * sdk.resize();
+     *
+     * @fires resize With current maxWidth and maxHeight
+     */
+    static resize() {
+        handleResize(sdk.maxWidth, sdk.maxHeight);
+    }
+    /**
+     * Forces the playable ad into a paused state.
+     *
+     * @example
+     * // Pause the experience
+     * pauseButton.onclick = () => sdk.pause();
+     *
+     * @fires pause When the ad enters paused state
+     */
+    static pause() {
+        if (!isForcePaused) {
+            isForcePaused = true;
+            handlePause();
+        }
+    }
+    /**
+     * Resumes the playable ad from a forced pause state.
+     * Only works if the ad was paused via sdk.pause().
+     *
+     * @example
+     * // Resume from pause
+     * resumeButton.onclick = () => sdk.resume();
+     *
+     * @fires resume When the ad resumes from pause
+     */
+    static resume() {
+        if (isForcePaused) {
+            isForcePaused = false;
+            handleResume();
+        }
+    }
+    /**
+     * Registers an event listener.
+     *
+     * @param event Name of the event to listen for
+     * @param fn Callback function to execute when event occurs
+     * @param context Optional 'this' context for the callback
+     *
+     * @example
+     * // Listen for user interactions
+     * sdk.on('interaction', (count) => {
+     *   console.log(`User interaction #${count}`);
+     * });
+     *
+     * // Listen for resize with context
+     * sdk.on('resize', function(width, height) {
+     *   this.updateLayout(width, height);
+     * }, gameInstance);
+     */
+    static on(event, fn, context) {
+        onEvent(event, fn, context);
+    }
+    /**
+     * Registers a one-time event listener that removes itself after execution.
+     *
+     * @param event Name of the event to listen for
+     * @param fn Callback function to execute when event occurs
+     * @param context Optional 'this' context for the callback
+     *
+     * @example
+     * // Listen for first interaction only
+     * sdk.once('interaction', () => {
+     *   console.log('First user interaction occurred!');
+     * });
+     */
+    static once(event, fn, context) {
+        onEvent(event, fn, context, true);
+    }
+    /**
+     * Removes an event listener.
+     *
+     * @param event Name of the event to stop listening for
+     * @param fn Optional callback function to remove (if not provided, removes all listeners for the event)
+     * @param context Optional 'this' context to match when removing
+     *
+     * @example
+     * // Remove specific listener
+     * const handler = () => console.log('Interaction');
+     * sdk.off('interaction', handler);
+     *
+     * // Remove all listeners for an event
+     * sdk.off('interaction');
+     */
+    static off(event, fn, context) {
+        offEvent(event, fn, context);
+    }
+}
+/** Current version of the SDK */
+sdk.version = '1.0.1';
+/** Current maximum width of the playable ad container in pixels */
+sdk.maxWidth = Math.floor(window.innerWidth);
+/** Current maximum height of the playable ad container in pixels */
+sdk.maxHeight = Math.floor(window.innerHeight);
+/** Indicates if the current orientation is landscape (width > height) */
+sdk.isLandscape = window.innerWidth > window.innerHeight;
+/** Indicates if the Ad Network is ready and playable ad can be initialized */
+sdk.isReady = false;
+/** Indicates if all playable ad resources are loaded and gameplay has started */
+sdk.isStarted = false;
+/** Indicates if the playable ad is currently paused */
+sdk.isPaused = false;
+/** Indicates if the playable ad has finished */
+sdk.isFinished = false;
+/** Current volume level (0-1) */
+sdk.volume = 1;
+/** Number of user interactions with the playable ad */
+sdk.interactions = 0;
+export { sdk };
+window.PlayableSDK = sdk;

package/dist/esm/events.d.ts

@@ -0,0 +1,4 @@
+export type EventName = 'init' | 'boot' | 'ready' | 'start' | 'interaction' | 'resize' | 'pause' | 'resume' | 'volume' | 'retry' | 'finish' | 'install';
+export declare function onEvent(event: EventName, fn: Function, context?: any, once?: boolean): void;
+export declare function offEvent(event: EventName, fn?: Function, context?: any): void;
+export declare function emitEvent(event: EventName, a1?: any, a2?: any, a3?: any): void;

package/dist/esm/events.js

@@ -0,0 +1,58 @@
+const registeredEvents = {};
+export function onEvent(event, fn, context, once) {
+    let listeners = registeredEvents[event];
+    if (!listeners) {
+        listeners = registeredEvents[event] = {
+            list: []
+        };
+    }
+    listeners.list.push(fn, context || null, once || false);
+}
+export function offEvent(event, fn, context) {
+    const listeners = registeredEvents[event];
+    if (!listeners)
+        return;
+    var fnArray = listeners.list;
+    if (!fn) {
+        fnArray.length = 0;
+    }
+    else {
+        let i = fnArray.length;
+        while (i > 0) {
+            i -= 3;
+            if (fnArray[i] == fn && (context !== undefined || fnArray[i + 1] == context)) {
+                fnArray.splice(i, 3);
+            }
+        }
+    }
+    if (fnArray.length == 0) {
+        delete registeredEvents[event];
+    }
+}
+export function emitEvent(event, a1, a2, a3) {
+    var listeners = registeredEvents[event];
+    if (!listeners)
+        return;
+    const fnArray = listeners.list;
+    const len = arguments.length;
+    let fn, ctx;
+    for (var i = 0; i < fnArray.length; i += 3) {
+        fn = fnArray[i];
+        ctx = fnArray[i + 1];
+        if (fnArray[i + 2]) {
+            fnArray.splice(i, 3);
+            i -= 3;
+        }
+        if (len <= 1)
+            fn.call(ctx);
+        else if (len == 2)
+            fn.call(ctx, a1);
+        else if (len == 3)
+            fn.call(ctx, a1, a2);
+        else
+            fn.call(ctx, a1, a2, a3);
+    }
+    if (fnArray.length == 0) {
+        delete registeredEvents[event];
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,2 @@
+export { sdk as default } from './core';
+export { sdk } from './core';