@cardsjd/portal 0.1.1 → 0.1.2

package/lib/PokiPortal.js

@@ -0,0 +1,303 @@
+import { BasePortal } from './BasePortal.js';
+
+export class PokiPortal extends BasePortal {
+	name = 'PokiPortal';
+	autoLogin = true;
+
+	constructor(appConfig) {
+		super();
+		this.appConfig = appConfig;
+
+		// Ad callback properties
+		this.onAdLoaded = null;
+		this.onAdOpened = null;
+		this.onAdClosed = null;
+		this.onAdError = null;
+		this.onAdRewarded = null;
+
+		this.adProviderName = 'poki';
+		this.isSetup = false;
+		this.isSetupLoading = false;
+	}
+
+	async init() {
+		if (typeof globalThis.PokiSDK === 'undefined') {
+			try {
+				await this.loadScript();
+			} catch (err) {
+				console.error('Failed to load Poki SDK script:', err);
+				return;
+			}
+		}
+
+		try {
+			await globalThis.PokiSDK.init();
+			this.isSetup = true;
+		} catch (err) {
+			console.warn('Poki SDK initialized with adblock or error:', err);
+			// Set isSetup = true to allow the game to continue even with adblock
+			this.isSetup = true;
+		}
+	}
+
+	async loadScript() {
+		return new Promise((resolve, reject) => {
+			const script = document.createElement('script');
+			script.src = 'https://game-cdn.poki.com/scripts/v2/poki-sdk.js';
+			script.onload = () => resolve();
+			script.onerror = () => reject(new Error('Failed to load Poki SDK script'));
+			document.head.appendChild(script);
+		});
+	}
+
+	isReady() {
+		return typeof globalThis.PokiSDK !== 'undefined' && this.isSetup;
+	}
+
+	async load() {
+		if (!this.isReady()) {
+			return;
+		}
+
+		const data = {};
+		try {
+			data.userdata = await this.loadData();
+			data.user = await this.loadUser();
+		} catch (err) {
+			console.warn('Failed to call Poki load:', err);
+		}
+
+		return data;
+	}
+
+	async save(data, _forceSave) {
+		if (!this.isReady()) {
+			return;
+		}
+
+		try {
+			globalThis.localStorage.setItem('poki_userdata', JSON.stringify(data));
+		} catch (err) {
+			console.warn('Failed to save Poki userdata to localStorage:', err);
+		}
+	}
+
+	async delete() {
+		if (!this.isReady()) {
+			return;
+		}
+
+		try {
+			globalThis.localStorage.removeItem('poki_userdata');
+		} catch (err) {
+			console.warn('Failed to delete Poki userdata from localStorage:', err);
+		}
+	}
+
+	async loadData() {
+		try {
+			const stringified = globalThis.localStorage.getItem('poki_userdata');
+			return stringified ? JSON.parse(stringified) : null;
+		} catch (err) {
+			console.warn('Failed to load Poki userdata from localStorage:', err);
+			return null;
+		}
+	}
+
+	async loadUser() {
+		if (!this.isReady()) {
+			return null;
+		}
+
+		try {
+			const userdetails = await globalThis.PokiSDK.getUser();
+			if (!userdetails) {
+				return null;
+			}
+
+			const user = {};
+			if (userdetails.username) {
+				user.name = userdetails.username;
+				user.pokiId = userdetails.username;
+			}
+
+			if (userdetails.avatarUrl) {
+				user.avatar = userdetails.avatarUrl;
+			}
+
+			return user;
+		} catch (err) {
+			console.warn('Failed to get Poki user details:', err);
+			return null;
+		}
+	}
+
+	gameStart() {
+		if (!this.isReady()) {
+			return;
+		}
+
+		try {
+			globalThis.PokiSDK.gameplayStart();
+		} catch (err) {
+			console.warn('Failed to call gameplayStart:', err);
+		}
+	}
+
+	gameStop() {
+		if (!this.isReady()) {
+			return;
+		}
+
+		try {
+			globalThis.PokiSDK.gameplayStop();
+		} catch (err) {
+			console.warn('Failed to call gameplayStop:', err);
+		}
+	}
+
+	loadStart() {
+		// Not explicitly needed for Poki, but we implement the base method
+	}
+
+	loadStop() {
+		if (!this.isReady()) {
+			return;
+		}
+
+		try {
+			globalThis.PokiSDK.gameLoadingFinished();
+		} catch (err) {
+			console.warn('Failed to call gameLoadingFinished:', err);
+		}
+	}
+
+	// ----- Ad methods -----
+
+	async setupAds() {
+		if (!this.isReady()) {
+			return false;
+		}
+
+		return true;
+	}
+
+	async loadAd() {
+		// Poki commercial breaks do not require manual preloading
+	}
+
+	async showAd() {
+		if (!this.isReady()) {
+			return false;
+		}
+
+		const adType = 'interstitial';
+		const adProvider = this.adProviderName;
+
+		try {
+			await globalThis.PokiSDK.commercialBreak(() => {
+				if (typeof this.onAdOpened === 'function') {
+					this.onAdOpened({
+						adType,
+						adProvider,
+					});
+				}
+			});
+
+			if (typeof this.onAdClosed === 'function') {
+				this.onAdClosed({
+					adType,
+					adProvider,
+				});
+			}
+
+			return true;
+		} catch (error) {
+			if (typeof this.onAdError === 'function') {
+				this.onAdError({
+					error,
+					adType,
+					adProvider,
+				});
+			}
+
+			if (typeof this.onAdClosed === 'function') {
+				this.onAdClosed({
+					adType,
+					adProvider,
+				});
+			}
+
+			return false;
+		}
+	}
+
+	isAdLoaded() {
+		return this.isReady();
+	}
+
+	isRewardedAdLoaded() {
+		return this.isReady();
+	}
+
+	async showRewardedAd() {
+		if (!this.isReady()) {
+			return false;
+		}
+
+		const adType = 'rewarded';
+		const adProvider = this.adProviderName;
+
+		try {
+			const success = await globalThis.PokiSDK.rewardedBreak({
+				onStart: () => {
+					if (typeof this.onAdOpened === 'function') {
+						this.onAdOpened({
+							adType,
+							adProvider,
+						});
+					}
+				},
+			});
+
+			if (success) {
+				if (typeof this.onAdRewarded === 'function') {
+					this.onAdRewarded({
+						adType,
+						adProvider,
+					});
+				}
+			}
+
+			if (typeof this.onAdClosed === 'function') {
+				this.onAdClosed({
+					adType,
+					adProvider,
+				});
+			}
+
+			return success;
+		} catch (error) {
+			if (typeof this.onAdError === 'function') {
+				this.onAdError({
+					error,
+					adType,
+					adProvider,
+				});
+			}
+
+			if (typeof this.onAdClosed === 'function') {
+				this.onAdClosed({
+					adType,
+					adProvider,
+				});
+			}
+
+			return false;
+		}
+	}
+
+	async loadRewardedAd() {
+		// Poki rewarded breaks do not require manual preloading
+	}
+}

package/lib/Portal.js

@@ -1,43 +1,47 @@
-import { Device } from '@cardsjd/device';
 import { BasePortal } from './BasePortal.js';
 import { CrazyGamesPortal } from './CrazyGamesPortal.js';
 import { FacebookPortal } from './FacebookPortal.js';
+import { GameDistribution } from './GameDistributionPortal.js';
+import { AndroidPortal } from './AndroidPortal.js';
+import { iOSPortal } from './iOSPortal.js';
 import { WebPortal } from './WebPortal.js';
+import { PokiPortal } from './PokiPortal.js';
 import { SteamPortal } from './SteamPortal.js';
 import { DiscordPortal } from './DiscordPortal.js';
-//import { GameDistributionPortal } from './GameDistributionPortal';
+
+import { Device } from '../../device';
 
 const PortalLoaders = {
+	android: AndroidPortal,
+	amazon: AndroidPortal,
 	crazygames: CrazyGamesPortal,
 	facebook: FacebookPortal,
+	ios: iOSPortal,
 	web: WebPortal,
 	windowsPWA: WebPortal,
 	windows: WebPortal,
-	stream: SteamPortal,
+	gameDistribution: GameDistribution,
+	poki: PokiPortal,
+	steam: SteamPortal,
 	discord: DiscordPortal,
-	Discord: DiscordPortal
-	//gamedistribution: GameDistributionPortal,
 };
 
-
 //Factory class for creating platform-specific portal instances.
 export class Portal {
 	/**
 	 * Creates and initializes a portal instance based on the current platform.
-	 * @param {string} platform - The platform identifier
 	 * @param {Object} appConfig - Configuration object to pass to the portal
-	 * @param {Object} advertisementConfig - Configuration object to pass to the portal
+	 * @param {string} platform - Platform to load, if undefined, will use Device class to determine platform
 	 * @returns {BasePortal} The initialized portal instance
 	 */
-	static create(platform, appConfig, advertisementConfig) {
+	static create(appConfig, platform) {
 
 		if (!platform) {
-			const device = new Device();
-			platform = device.getPlatform();
+			platform = Device.getPlatform();
 		}
 
-		const portalClass = PortalLoaders[platform] || BasePortal;
-		const portal = new portalClass(appConfig, advertisementConfig);
+		const portalClass = PortalLoaders[platform];
+		const portal = portalClass ? new portalClass(appConfig) : new BasePortal(appConfig);
 
 		return portal;
 	}

package/lib/WebPortal.js

@@ -6,25 +6,252 @@ export class WebPortal extends BasePortal {
 	config = {};
 	constructor(config) {
 		super();
-		this.config.version = config?.version;
+		this.config = config;
+
+		// Ad callback properties
+		this.onAdLoaded = null;
+		this.onAdOpened = null;
+		this.onAdClosed = null;
+		this.onAdError = null;
+		this.onAdRewarded = null;
+
+		this.page_url = 'cardsjd.com';
+		this.adProviderName = 'GoogleH5';
+		this.isSetup = false;
+		this.isSetupLoading = false;
 	}
+
 	async init() {
 		//set update google analytics dynamically
 		//some platforms may block google analytics, so only add it for web portal
 		this.addGoogleAnalytics(this.config.version); //no await no - fire and forget
 	}
+
 	//todo: move to lib so other portals can use it too
 	async addGoogleAnalytics(version) {
 		console.log('WebPortal: Initializing Google Analytics');
 		//set update google analytics dynamically
 		await import('https://www.googletagmanager.com/gtag/js?id=G-BMWB7H1PDJ');
-		window.dataLayer = window.dataLayer || [];
-		function gtag() { dataLayer.push(arguments); }
+		globalThis.dataLayer = globalThis.dataLayer || [];
+		function gtag() {
+			globalThis.dataLayer.push(arguments);
+		}
+
 		gtag('js', new Date());
 
 		gtag('config', 'G-BMWB7H1PDJ', {
-			app_version: version
+			app_version: version,
 		});// for Cribbage all platforms
 		gtag('config', 'G-SBZ83TJLW6');// for website cardsjd.com
 	}
-}
+
+	// ----- Ad methods -----
+
+	async setupAds() {
+		if (this.isSetupLoading) {
+			throw Error('GoogleH5 setup is in progress already');
+		}
+
+		this.isSetupLoading = true; //prevent async loading
+
+		if (this.isSetup) {
+			console.log('GoogleH5.isSetup is already done');
+			return;
+		}
+
+		try {
+			await this.loadScript();
+			console.log('adsbygoogle loaded');
+		} catch (error) {
+			console.log(error);
+			return;
+		}
+
+		if (typeof adConfig === 'undefined') {
+			console.log('GoogleH5 adBreak plugin not ready');
+			throw Error('GoogleH5 adBreak plugin not ready');
+		}
+
+		globalThis.adConfig({
+			preloadAdBreaks: 'on',
+			sound: 'on', //todo: check if muted or not
+			onReady: () => {
+				console.log('GoogleH5.isSetup is ready');
+			},
+		});
+		this.isSetup = true;
+		this.isSetupLoading = false;
+	}
+
+	async loadScript() {
+		return new Promise((resolve, reject) => {
+			window.adsbygoogle = window.adsbygoogle || [];
+
+			window.adBreak = window.adConfig = function (o) {
+				globalThis.adsbygoogle.push(o);
+			};
+
+			const ad_client = this.config?.adClient;
+			const ad_channel = this.config?.interstitialAdId;
+			const page_url = this.page_url;
+			const script = document.createElement('script');
+			script.src = 'https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js';
+			script.setAttribute('async', '');
+			script.setAttribute('data-ad-client', ad_client);
+			script.setAttribute('data-ad-channel', ad_channel);
+			script.setAttribute('data-ad-frequency-hint', '60s');
+			script.setAttribute('data-page-url', page_url);
+			script.setAttribute('crossorigin', 'anonymous');
+
+			script.onload = () => {
+				resolve('adsbygoogle loaded');
+			};
+
+			script.onerror = () => {
+				reject('Error loading JS adsbygoogle');
+			};
+
+			document.head.appendChild(script);
+		});
+	}
+
+	loadAd() {
+		console.log('GoogleH5.loadAd');
+	}
+
+	showAd() {
+		console.log('GoogleH5.showAd');
+
+		if (typeof adBreak === 'undefined' || !globalThis.adBreak) {
+			console.log('GoogleH5 adBreak plugin not ready'); return;
+		}
+
+		if (!this.isSetup) {
+			console.log('GoogleH5.showAd - isSetup is false');
+			return;
+		}
+
+		globalThis.adBreak({
+			type: 'next', // The type of this placement (required)
+			name: 'post_game', // A descriptive name for this placement
+			beforeAd: () => {
+				if (this.onAdOpened) {
+					this.onAdOpened({
+						adType: 'interstitial',
+						adProvider: this.adProviderName,
+					});
+				}
+			},
+			afterAd: () => {
+				if (this.onAdClosed) {
+					this.onAdClosed({
+						adType: 'interstitial',
+						adProvider: this.adProviderName,
+					});
+				}
+			},
+			adBreakDone: (placementInfo) => {
+				console.log('placementInfo', placementInfo);
+			},
+		});
+	}
+
+	isAdLoaded() {
+		return true;
+	}
+
+	isRewardedAdLoaded() {
+		return true;
+	}
+
+	showRewardedAd() {
+		console.log('GoogleH5.ShowRewardedAd');
+
+		if (typeof globalThis.adBreak === 'undefined' || !globalThis.adBreak) {
+			console.log('GoogleH5 adBreak plugin not ready'); return;
+		}
+
+		globalThis.adBreak({
+			type: 'reward',
+			name: 'reward_ad',
+			beforeAd: () => {
+				if (this.onAdOpened) {
+					this.onAdOpened({
+						adType: 'rewarded',
+						adProvider: this.adProviderName,
+					});
+				}
+			},
+			afterAd: () => { },
+			beforeReward: (showAdFn) => {
+				showAdFn();
+			},
+			adDismissed: () => { },
+			adViewed: () => {
+				if (this.onAdClosed) {
+					this.onAdClosed({
+						adType: 'rewarded',
+						adProvider: this.adProviderName,
+					});
+				}
+
+				if (this.onAdRewarded) {
+					this.onAdRewarded({
+						adType: 'rewarded',
+						rewardAmount: 150,
+						adProvider: this.adProviderName,
+					});
+				}
+			},
+			adBreakDone: (placementInfo) => {
+				console.log('placementInfo', placementInfo);
+			},
+		});
+
+	}
+
+	loadRewardedAd() {
+		console.log('GoogleH5.loadRewardedAd');
+	}
+
+	async showAppOpenAd(successCallback) {
+		console.log('GoogleH5.ShowAppOpenAd');
+
+		if (typeof globalThis.adBreak === 'undefined' || !globalThis.adBreak) {
+			console.log('GoogleH5 adBreak plugin not ready'); return;
+		}
+
+		const adStatus = await new Promise((resolve) => {
+			globalThis.adBreak({
+				type: 'preroll',
+				adBreakDone: (e) => {
+					const status = e.breakStatus;
+
+					if (successCallback) {
+						successCallback(e);
+					}
+
+					resolve(status);
+				},
+			});
+		});
+
+		if (adStatus === 'viewed') {
+			if (this.onAdOpened) {
+				this.onAdOpened({
+					adType: 'app_open',
+					adProvider: this.adProviderName,
+				});
+			}
+
+			if (this.onAdClosed) {
+				this.onAdClosed({
+					adType: 'app_open',
+					adProvider: this.adProviderName,
+				});
+			}
+		}
+
+		return adStatus;
+	}
+}

package/lib/iOSPortal.js

@@ -0,0 +1,7 @@
+import { AdMobPortal } from './AdMobPortal';
+
+export class iOSPortal extends AdMobPortal {
+	name = 'iOSPortal';
+
+
+}

package/lib/index.js

@@ -1,5 +1,3 @@
 import { Portal } from './Portal';
 
-export {
-  Portal
-};
+export { Portal };

package/package.json

@@ -1,7 +1,7 @@
 {
-  "name": "@cardsjd/portal",
+	"name": "@cardsjd/portal",
   "private": false,
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "main": "lib/index.js",
   "publishConfig": {
@@ -14,12 +14,10 @@
     "lint": "eslint lib --report-unused-disable-directives --max-warnings 0",
     "lint:fix": "npm run lint -- --fix"
   },
+  "devDependencies": {},
   "dependencies": {
-    "@cardsjd/device": "^0.1.14",
-    "@cardsjd/fbinstantgame": "^0.1.12",
+    "@capacitor-community/admob": "^7.0.3",
     "@discord/embedded-app-sdk": "^2.4.0"
   },
-  "peerDependencies": {
-    "@sagi.io/globalthis": "^0.0.2"
-  }
+  "peerDependencies": {}
 }