@cardsjd/portal 0.1.0

package/README.md

@@ -0,0 +1,11 @@
+# Portal
+
+Use:
+
+```js
+import { Portal } from '@cardsjd/portal';
+
+const portal = Portal.create(platform, appConfig, userdata, advertisementConfig);
+```
+
+The package exports the portal factory and concrete portal classes.

package/lib/BasePortal.js

@@ -0,0 +1,30 @@
+export class BasePortal {
+
+	async init() { }
+
+	async load() { }
+
+	async save(data, forceSave) { }
+	
+	async delete() { }
+
+	gameStart() { }
+
+	gameStop() { }
+
+	loadStart() { }
+
+	loadStop() { }
+
+	async getInvite() { }
+
+	async inviteSend(user, room) { }
+
+	async findAndInvite(userFrom, room) { }
+
+	async getFriends() { }
+
+	tryShowInterstitialAd() { }
+
+	createShortCut() { }
+}

package/lib/CrazyGamesPortal.js

@@ -0,0 +1,190 @@
+import { BasePortal } from './BasePortal';
+
+export class CrazyGamesPortal extends BasePortal {
+	name = 'CrazyGamesPortal';
+	autoLogin = true;
+	hideMoreGames = true;
+	hideSuggestions = false;
+	hideReportBug = false;
+
+	async init() {
+		try {
+			await import('https://sdk.crazygames.com/crazygames-sdk-v3.js');
+
+			const sdk = globalThis.CrazyGames.SDK;
+			await sdk.init();
+		} catch (err) {
+			console.error('failed to load crazygames', err);
+		}
+
+	}
+	isCrazyGames() {
+		if (typeof globalThis.CrazyGames === 'undefined') return false;
+		if (!globalThis.CrazyGames.SDK) return false;
+		if (globalThis.CrazyGames.SDK.environment === "disabled") {
+			console.log('CrazyGames SDK is disabled');
+			return false;
+		}
+		return true;
+	}
+	async load() {
+		if (!this.isCrazyGames()) return;
+
+		const data = {};
+		try {
+			data.userdata = await this.loadData();
+			data.user = await this.loadUser();
+		} catch (err) {
+			console.warn('Failed to call CrazyGames SDK load:', err);
+		}
+		return data;
+	}
+	async save(data, forceSave) {
+		if (!this.isCrazyGames()) {
+			return;
+		}
+
+		const sdk = globalThis.CrazyGames.SDK;
+		if (!sdk.data) return;
+
+		sdk.data.setItem("userdata", JSON.stringify(data));
+
+	}
+	async delete() {
+		if (!this.isCrazyGames()) {
+			return;
+		}
+		const sdk = globalThis.CrazyGames.SDK;
+		if (!sdk.data) return;
+
+		sdk.data.clear();
+	}
+	async loadData() {
+		if (!this.isCrazyGames()) {
+			return null;
+		}
+		const sdk = globalThis.CrazyGames.SDK;
+		if (!sdk.data) return null;
+
+		//get userdata from crazygames storage - and get newest data
+		const userdata_crazyGame_string = sdk.data.getItem('userdata');
+		if (!userdata_crazyGame_string) {
+			return null;
+		}
+
+		try {
+			const portalUserdata = JSON.parse(userdata_crazyGame_string);
+			return portalUserdata;
+		} catch (err) {
+			console.warn('Failed to parse CrazyGames userdata:', err);
+			return null;
+		}
+
+	}
+	async loadUser() {
+		if (!this.isCrazyGames()) {
+			return null;
+		}
+
+		const sdk = globalThis.CrazyGames.SDK;
+		if (!sdk.data) return null;
+
+		
+
+		if (!sdk.user.isUserAccountAvailable) {
+			return null;
+		}
+
+		const user = {};
+		try {
+			const userdetails = await sdk.user.getUser();
+
+			// Add null check for userdetails
+			if (!userdetails) {
+				console.warn('CrazyGames getUser returned null/undefined');
+				return null;
+			}
+
+			if (userdetails?.username) {
+				user.name = userdetails.username;
+				user.crazyGamesId = userdetails.username; //use username for now, not actual userid from crazy games, too many steps and higher risk of failure
+			}
+			if (userdetails?.profilePictureUrl) {
+				user.avatar = userdetails.profilePictureUrl;
+			}
+		} catch (err) {
+			console.warn('Failed to get CrazyGames user details:', err);
+			return null;
+		}
+
+		////options #1 - Get or Create User ID
+		////cascade login from most complicated to least complicated safe failing method
+		////////// getting Crazy Game userid is disabled for now, it will slow the server down too much - Rely on auto created accounts for now and the local stoage and crazy games data restore.
+		// // // //get userToken
+		// // // try {
+		// // //   const userToken = await window.CrazyGames.SDK.user.getUserToken();
+		// // //   if (userToken) {
+		// // //     const data = await this.accountJD.CrazyGameUserData(userToken);
+		// // //     if (data) {
+		// // //       if (data.id) userdata.crazyGamesId = data.id;
+		// // //     }
+		// // //   }
+		// // // } catch (e) { }
+
+
+		return user;
+	}
+
+	gameStart() {
+		if (!this.isCrazyGames()) {
+			return;
+		}
+
+		try {
+			const sdk = globalThis.CrazyGames.SDK;
+			sdk.game.gameplayStart();
+		} catch (err) {
+			console.warn('Failed to call gameplayStart:', err);
+		}
+	}
+
+	gameStop() {
+		if (!this.isCrazyGames()) {
+			return;
+		}
+
+		try {
+			const sdk = globalThis.CrazyGames.SDK;
+			sdk.game.gameplayStop();
+		} catch (err) {
+			console.warn('Failed to call gameplayStop:', err);
+		}
+	}
+
+	loadStart() {
+		if (!this.isCrazyGames()) {
+			return;
+		}
+
+		try {
+			const sdk = globalThis.CrazyGames.SDK;
+			sdk.game.loadingStart();
+		} catch (err) {
+			console.warn('Failed to call loadingStart:', err);
+		}
+	}
+
+	loadStop() {
+		if (!this.isCrazyGames()) {
+			return;
+		}
+
+		try {
+			const sdk = globalThis.CrazyGames.SDK;
+			sdk.game.loadingStop();
+		} catch (err) {
+			console.warn('Failed to call loadingStop:', err);
+		}
+	}
+
+}

package/lib/Discord.js

@@ -0,0 +1,144 @@
+import { DiscordSDK } from "@discord/embedded-app-sdk";
+
+export default class Discord {
+    constructor(options) {
+        this.client_id = options.discordClientId;
+        this.discordSdk = null;
+        this.auth = null;
+    }
+    isOnDiscord() {
+        //check url for discord
+        const isOnDiscord = window.location.host.includes("discord") || (window.location.href.includes("localhost") &&window.location.href.includes("frame_id"));
+        return isOnDiscord;
+    }
+    async getData() {
+        //get name and avatar
+        let auth = await this.setupDiscordSdk();
+        let guildMemeber = await this.getGuildMember(auth.access_token);
+        let name = this.getUserDisplayName(auth.user, guildMemeber);
+        console.log("Discord Name", name);
+        let avatar = this.getUserAvatarUrl(auth.user, guildMemeber);
+        console.log("Discord Avatar", avatar);
+        const discordId = guildMemeber?.user?.id;
+        let data = {
+            name: name,
+            avatar: avatar,
+            guildId: this.discordSdk.guildId,
+            guildMemeber: guildMemeber,
+            discordId: discordId
+        }
+        return data;
+    }
+    async setupDiscordSdk() {
+        const clientId = this.client_id || import.meta.env.VITE_DISCORD_CLIENT_ID;
+        console.log("Initializing Discord SDK with Client ID:", clientId);
+        this.discordSdk = new DiscordSDK(clientId);
+        await this.discordSdk.ready();
+        console.log("Discord SDK is ready");
+
+        // Authorize with Discord Client
+        const { code } = await this.discordSdk.commands.authorize({
+            client_id: clientId,
+            response_type: "code",
+            state: "",
+            prompt: "none",
+            scope: [
+                "identify",
+                "applications.commands",
+                "guilds",
+                "guilds.members.read"
+            ],
+        });
+
+        // Retrieve an access_token from your activity's server
+        //const response = await fetch("/.proxy/api/token", {
+        const response = await fetch("/api/token/discord", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                code: code,
+                ClientId: clientId
+            }),
+        });
+        const { access_token } = await response.json();
+
+        // Authenticate with Discord client (using the access_token)
+        this.auth = await this.discordSdk.commands.authenticate({
+            access_token,
+        });
+        console.log("Authenticated with Discord Client", this.auth);
+        if (this.auth == null) {
+            throw new Error("Authenticate command failed");
+        }
+        return this.auth;
+    }
+    async getGuildMember(access_token, discordSdk) {
+        if (!access_token) auth = this.auth.access_token;
+        if (!discordSdk) discordSdk = this.discordSdk;
+        // Get guild specific nickname and avatar, and fallback to user name and avatar
+        const guildMember = await fetch(
+            `https://discord.com/api/v10/users/@me/guilds/${discordSdk.guildId}/member`,
+            {
+                method: 'get',
+                headers: { Authorization: `Bearer ${access_token}` },
+            },
+        )
+            .then((j) => j.json())
+            .catch(() => {
+                return null;
+            });
+        return guildMember;
+    }
+    getUserDisplayName(user, guildMember) {
+        if (guildMember?.nick != null && guildMember.nick !== '') return guildMember.nick;
+
+        if (user.discriminator !== '0') return `${user.username}#${user.discriminator}`;
+
+        if (user.global_name != null && user.global_name !== '') return user.global_name;
+
+        return user.username;
+    }
+
+    getUserAvatarUrl(user, guildMember, discordSdk, cdn = `https://cdn.discordapp.com`, size = 256) {
+        if (!user) user = this.auth.user;
+        if (!discordSdk) discordSdk = this.discordSdk;
+
+        if (guildMember?.avatar != null && discordSdk.guildId != null) {
+            return `${cdn}/guilds/${discordSdk.guildId}/users/${user.id}/avatars/${guildMember.avatar}.png?size=${size}`;
+        }
+        if (user.avatar != null) {
+            return `${cdn}/avatars/${user.id}/${user.avatar}.png?size=${size}`;
+        }
+
+        const defaultAvatarIndex = Math.abs(Number(user.id) >> 22) % 6;
+        return `${cdn}/embed/avatars/${defaultAvatarIndex}.png?size=${size}`;
+    }
+
+    async appendGuildAvatar() {
+        const app = document.querySelector('#app');
+
+        // 1. From the HTTP API fetch a list of all of the user's guilds
+        const guilds = await fetch(`https://discord.com/api/v10/users/@me/guilds`, {
+            headers: {
+                // NOTE: we're using the access_token provided by the "authenticate" command
+                Authorization: `Bearer ${this.auth.access_token}`,
+                'Content-Type': 'application/json',
+            },
+        }).then((response) => response.json());
+
+        // 2. Find the current guild's info, including it's "icon"
+        const currentGuild = guilds.find((g) => g.id === this.discordSdk.guildId);
+
+        // 3. Append to the UI an img tag with the related information
+        if (currentGuild != null) {
+            return `https://cdn.discordapp.com/icons/${currentGuild.id}/${currentGuild.icon}.webp?size=128`;
+        }
+        else {
+            return null;
+        }
+    }
+
+
+}

package/lib/DiscordPortal.js

@@ -0,0 +1,34 @@
+import { BasePortal } from './BasePortal';
+import Discord from './Discord.js';
+
+export class DiscordPortal extends BasePortal {
+	name = 'DiscordPortal';
+	discord = null;
+
+	constructor(config) {
+		super();
+		this.discord = new Discord(config || {});
+	}
+
+	async load() {
+		if (!this.discord?.isOnDiscord?.()) {
+			return {};
+		}
+
+		const data = await this.discord.getData();
+		if (!data) {
+			return {};
+		}
+
+		return {
+			user: {
+				name: data.name,
+				avatar: data.avatar,
+				avatar_discord: data.avatar,
+				discordId: data.discordId,
+				guildId: data.guildId,
+				roomId: data.guildId
+			}
+		};
+	}
+}

package/lib/FacebookPortal.js

@@ -0,0 +1,81 @@
+import { BasePortal } from './BasePortal';
+import { FBInstantGame } from '@cardsjd/fbinstantgame';
+
+export class FacebookPortal extends BasePortal {
+	name = 'FacebookPortal';
+	fBInstantGame = null;
+
+	constructor(config, advertisementConfig) {
+		super();
+		this.fBInstantGame = new FBInstantGame(config);
+		this.advertisementConfig = advertisementConfig;
+	}
+	async init() {
+		await this.fBInstantGame.initialize();
+	}
+	isAvailable() {
+
+		return true;
+	}
+	async load() {
+		const fbUserdata = await this.fBInstantGame.loadData();
+		const fbProfile = await this.fBInstantGame.getProfile();
+		const data = {};
+		data.userdata = fbUserdata;
+		data.user = fbProfile;
+		return data;
+	}
+	async save(data, forceSave) {
+		this.fBInstantGame.saveData(data, forceSave).catch(function () { });
+	}
+	gameStart() {
+	}
+
+	gameStop() {
+	}
+
+	loadStart() {
+		//it is inside the data load fBInstantGame.initialize or fBInstantGame.loadData
+	}
+
+	loadStop() {
+		//it is inside the data load fBInstantGame.initialize or fBInstantGame.loadData
+
+		//try create shortcut after load (could be a portal level function, for now just call it here until other platforms need it)
+		this.createShortCutTry();
+		this.subscribeBot();
+	}
+	createShortCut() {
+		this.portal?.createShortCut?.();
+	}
+	async subscribeBot() {
+		await this.fBInstantGame.subscribeBot();
+	}
+	createShortCut() {
+		this.fBInstantGame.createShortcut();
+	}
+	async getInvite() {
+		//returns {message,room}
+		return this.fBInstantGame.getInvite();
+	}
+	async invite(userId, room) {
+		return this.fBInstantGame.invitePlayer(userId, room);
+	}
+	async findAndInvite(userFrom, room) {
+		return this.fBInstantGame.inviteSend(userFrom, room);
+	}
+	async getFriends() {
+		const fbUsers = await this.fBInstantGame.getConnectedPlayersAsync();
+		if (!fbUsers) return [];
+		const friends = [];
+		for (let i = 0; i < fbUsers.length; i++) {
+			const fbUser = fbUsers[i];
+
+			//Facebook only gaves the facebookid, no name or userid
+			const facebookId = fbUser.getID();
+			friends.push({ facebookId: facebookId });
+		}
+		return friends;
+	}
+
+}

package/lib/GameDistributionPortal.js

@@ -0,0 +1,72 @@
+import { BasePortal } from './BasePortal';
+
+const isGameDistribution = () => typeof globalThis.gdsdk !== 'undefined';
+
+export class GameDistributionPortal extends BasePortal {
+	name = 'GameDistributionPortal';
+	isInitialized = false;
+	isError = false;
+
+	async init() {
+
+	}
+
+	async load(userdata, advertisementConfig) {
+		if (!this.isInitialized && advertisementConfig.gameDistributionId) {
+			await this.#doInit(advertisementConfig.gameDistributionId);
+		}
+
+		if (!isGameDistribution()) {
+			return;
+		}
+	}
+
+	tryShowInterstitialAd() {
+		if (!isGameDistribution()) {
+			return;
+		}
+
+		globalThis?.gdsdk?.showAd?.();
+	}
+
+	async #doInit(gameId) {
+		if (!this.isError) {
+			globalThis.GD_OPTIONS = {
+				gameId,
+				onEvent: (event) => {
+					this.#handleEvent(event);
+				},
+			};
+
+			try {
+				await import('https://html5.api.gamedistribution.com/main.min.js');
+				this.isInitialized = true;
+			} catch (err) {
+				console.error('Failed to load GameDistribution');
+				this.isError = true;
+			}
+		}
+	}
+
+	async #handleEvent(event) {
+		console.log('got event from GD', event);
+
+		switch (event.name) {
+			case 'SDK_GAME_START':
+				// advertisement done, resume game logic and unmute audio
+				break;
+			case 'SDK_GAME_PAUSE':
+				// pause game logic / mute audio
+				break;
+			case 'SDK_GDPR_TRACKING':
+				// this event is triggered when your user doesn't want to be tracked
+				break;
+			case 'SDK_GDPR_TARGETING':
+				// this event is triggered when your user doesn't want personalised targeting of ads and such
+				break;
+			case 'SDK_REWARDED_WATCH_COMPLETE':
+				// this event is triggered when your user completely watched rewarded ad
+				break;
+		}
+	}
+}

package/lib/Portal.js

@@ -0,0 +1,44 @@
+import { Device } from '@cardsjd/device';
+import { BasePortal } from './BasePortal.js';
+import { CrazyGamesPortal } from './CrazyGamesPortal.js';
+import { FacebookPortal } from './FacebookPortal.js';
+import { WebPortal } from './WebPortal.js';
+import { SteamPortal } from './SteamPortal.js';
+import { DiscordPortal } from './DiscordPortal.js';
+//import { GameDistributionPortal } from './GameDistributionPortal';
+
+const PortalLoaders = {
+	crazygames: CrazyGamesPortal,
+	facebook: FacebookPortal,
+	web: WebPortal,
+	windowsPWA: WebPortal,
+	windows: WebPortal,
+	stream: 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
+	 * @returns {BasePortal} The initialized portal instance
+	 */
+	static create(platform, appConfig, advertisementConfig) {
+
+		if (!platform) {
+			const device = new Device();
+			platform = device.getPlatform();
+		}
+
+		const portalClass = PortalLoaders[platform] || BasePortal;
+		const portal = new portalClass(appConfig, advertisementConfig);
+
+		return portal;
+	}
+}

package/lib/SteamPortal.js

@@ -0,0 +1,52 @@
+import { BasePortal } from './BasePortal';
+
+export class SteamPortal extends BasePortal {
+	name = 'SteamPortal';
+	config = {};
+	constructor(config) {
+		super();
+		this.config.version = config?.version;
+	}
+	async init() {
+	}
+	async load() {
+		const params = new URLSearchParams(window.location.search);
+		const steamUserdata = {};
+		const steamProfile = {};
+
+		const name = params.get('name');
+		const avatar = params.get('avatar');
+		const steamId = params.get('steamId');
+
+		if (name) {
+			steamUserdata.name = name;
+			steamProfile.name = name;
+		}
+		if (steamId) {
+			steamUserdata.steamId = steamId;
+		}
+
+		let resolvedAvatar = avatar;
+		if (!resolvedAvatar && steamId) {
+			resolvedAvatar = await this.getSteamAvatar(steamId);
+		}
+		if (resolvedAvatar) {
+			steamUserdata.avatar = resolvedAvatar;
+			steamProfile.avatar = resolvedAvatar;
+		}
+
+		return {
+			userdata: steamUserdata,
+			user: steamProfile
+		};
+	}
+	async getSteamAvatar(steamId) {
+		let url = `https://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key=B362E8813B70415ADF5002D05C4353C5&steamids=[${steamId}]`;
+		let response = await fetch(url);
+		let data = await response.json();
+
+		if (!data || !data.response || !data.response.players || !data.response.players[0]) return;
+		return data.response.players[0].avatarfull;
+	}
+	
+}

package/lib/WebPortal.js

@@ -0,0 +1,30 @@
+import { BasePortal } from './BasePortal';
+
+export class WebPortal extends BasePortal {
+	name = 'WebPortal';
+	autoLogin = false;
+	config = {};
+	constructor(config) {
+		super();
+		this.config.version = config?.version;
+	}
+	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); }
+		gtag('js', new Date());
+
+		gtag('config', 'G-BMWB7H1PDJ', {
+			app_version: version
+		});// for Cribbage all platforms
+		gtag('config', 'G-SBZ83TJLW6');// for website cardsjd.com
+	}
+}

package/lib/index.js

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

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@cardsjd/portal",
+  "private": false,
+  "version": "0.1.0",
+  "type": "module",
+  "main": "lib/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "lint": "eslint lib --report-unused-disable-directives --max-warnings 0",
+    "lint:fix": "npm run lint -- --fix"
+  },
+  "dependencies": {
+    "@cardsjd/device": "^0.1.14",
+    "@cardsjd/fbinstantgame": "^0.1.12",
+    "@discord/embedded-app-sdk": "^2.4.0"
+  },
+  "peerDependencies": {
+    "@sagi.io/globalthis": "^0.0.2"
+  }
+}