@arkadiuminc/sdk 2.35.3 → 2.36.1

package/dist/pkg/api/features/auth/index.d.ts

@@ -28,10 +28,12 @@ interface AuthUIManagerContract {
     openAuthRequest: ReturnType<typeof createStore<boolean>>;
     openAuthForm(): Promise<void>;
 }
+export declare function getAvatarLink(avatarName: string, extension: string): string;
 export declare abstract class Auth {
     private backendApi;
     protected userProfileReader: UserProfileReaderContract;
     protected authUIManager: AuthUIManagerContract | undefined;
+    private userId?;
     constructor(backendApi: Backend, host: IHost);
     init(): Promise<void>;
     isUserAuthorized(): Promise<boolean>;
@@ -40,6 +42,7 @@ export declare abstract class Auth {
     onAuthStatusChange(observer: any): () => void;
     openAuthForm(): Promise<void>;
     onOpenAuthForm(observer: any): (() => void) | undefined;
+    getUserId(): Promise<string | undefined>;
 }
 export declare class AuthArena extends Auth {
     constructor(backendApi: Backend, host: IHost, rpcProvider: RpcProvider);

package/dist/pkg/api/features/chat/index.d.ts

@@ -0,0 +1,88 @@
+import { Presence } from '@heroiclabs/nakama-js';
+import { NakamaProvider } from '../nakama/nakama-provider';
+import { NakamaService } from '../nakama/nakama-service';
+import { NotificationsArena, Notification } from '../notifications';
+import { FriendsArena } from '../friends';
+
+declare enum ChatType {
+    Direct = "direct",
+    Public = "public"
+}
+export interface JoinChatResponse {
+    id: string;
+    user_id_one?: string;
+    user_id_two?: string;
+    room_name?: string;
+    self: Presence;
+    presences: Presence[];
+}
+export declare type ChatChannel = {
+    id: string;
+    name: string;
+    target: string;
+    type: ChatType;
+    presences: ChatPresence[];
+    messages: ChatMessage[];
+};
+export declare type ChatPresence = {
+    chatId: string;
+    userId: string;
+    sessionId: string;
+    username: string;
+};
+export declare type ChatMessage = {
+    id?: string;
+    chatId?: string;
+    content?: object;
+    senderId?: string;
+    username?: string;
+    createTime?: string;
+    updateTime?: string;
+};
+export declare type GetChatMessagesParams = {
+    chatId: string;
+    fromCache?: boolean;
+    limit?: number;
+};
+export declare type ChatPresencesListener = (presence: ChatPresence[]) => void;
+export declare type ChatMessageListener = (message: ChatMessage) => void;
+export declare type ChatInviteListener = (invite: Notification) => void;
+export declare class ChatArena extends NakamaService {
+    private _notificationsService;
+    private _friendsService;
+    private _chatList;
+    private _autoJoinChat;
+    private _chatMessagesCursor?;
+    private readonly _delayBeforeProcessing;
+    private _notificationListenerRemover;
+    private _chatPresencesListener?;
+    private _chatMessageListener?;
+    private _chatInviteListener?;
+    constructor(nakamaProvider: NakamaProvider, _notificationsService: NotificationsArena, _friendsService: FriendsArena);
+    setAutoJoinChat(isEnabled: boolean): void;
+    getJoinedChats(): ChatChannel[];
+    getChatMessages({ chatId, fromCache, limit }: GetChatMessagesParams): Promise<ChatMessage[]>;
+    joinDirectChat(userId: string): Promise<ChatChannel>;
+    private joinChat;
+    sendMessageWithFriendId(userId: string, data: object): Promise<void>;
+    sendMessageWithChatId(chatId: string, data: object): Promise<void>;
+    leaveChat(chatId: string): Promise<void>;
+    private removeChatPresence;
+    private addChatPresences;
+    private addChatPresence;
+    private addChatMessage;
+    private addChatMessages;
+    private handleJoinChatInvitation;
+    private mapNakamaChannelMessageToChatMessage;
+    private onChannelPresenceChanged;
+    subscribeChatPresenceListener(listener: ChatPresencesListener): void;
+    removeChatPresenceListener(): void;
+    private onChannelMessageChanged;
+    subscribeChatMessageListener(listener: ChatMessageListener): void;
+    removeChatMessageListener(): void;
+    private onChatInviteNotification;
+    subscribeChatInviteListener(listener: ChatInviteListener): void;
+    removeChatInviteListener(): void;
+    protected onSocketConnectionChanged(isConnected: boolean): void;
+}
+export {};

package/dist/pkg/api/features/friends/index.d.ts

@@ -0,0 +1,59 @@
+import { NakamaProvider } from '../nakama/nakama-provider';
+import { Auth } from '../auth/index';
+import { NakamaService } from '../nakama/nakama-service';
+import { NotificationsArena, NotificationListener } from '../notifications';
+
+export declare const FRIEND_STATE_FRIENDS: number;
+export declare const FRIEND_STATE_SENT_REQUEST: number;
+export declare const FRIEND_STATE_RECEIVED_REQUEST: number;
+export declare const FRIEND_STATE_BLOCKED: number;
+export declare enum FriendshipState {
+    None = "none",
+    Friends = "friends",
+    RequestSent = "request_sent",
+    RequestReceived = "request_received",
+    Blocked = "blocked"
+}
+declare type Friend = {
+    avatarUrl?: string;
+    displayName?: string;
+    id?: string;
+    online?: boolean;
+    username?: string;
+    friendshipState?: FriendshipState;
+    status?: any;
+};
+export declare class FriendsArena extends NakamaService {
+    private _auth;
+    private _notificationsService;
+    private _friendsOnlineListener?;
+    private _friendsJoinedListener?;
+    private _friendsLeftListener?;
+    private _friendStatus;
+    private _notificationListenerRemovers;
+    constructor(nakamaProvider: NakamaProvider, _auth: Auth, _notificationsService: NotificationsArena);
+    private compressUUID;
+    private decompressUUID;
+    getFriendlyId(): Promise<string>;
+    getFriendlyIdWithEagleId(eagleId: any): string;
+    sendFriendRequestWithFriendlyId(friendlyId: string): Promise<void>;
+    sendFriendRequestWithUserId(userId: string): Promise<void>;
+    private sendFriendRequest;
+    acceptFriendRequest(friendId: string): Promise<void>;
+    rejectFriendRequest(friendId: string): Promise<void>;
+    removeFriend(friendId: string): Promise<void>;
+    getFriends(): Promise<Array<Friend>>;
+    getOnlineFriends(): Promise<Array<Friend>>;
+    isFriend(userId: string): Promise<boolean>;
+    private followFriends;
+    private unfollowFriends;
+    private onStatusPresenceChanged;
+    protected onSocketConnectionChanged(isConnected: boolean): void;
+    subscribeFriendRequestNotificationListener(listener: NotificationListener): void;
+    subscribeFriendRequestAcceptedNotificationListener(listener: NotificationListener): void;
+    subscribeFriendsOnlineListener(listener: (onlineFriends: Array<Friend>) => void): void;
+    subscribeFriendsJoinedListener(listener: (joinedFriends: Array<Friend>) => void): void;
+    subscribeFriendsLeftListener(listener: (leftFriends: Array<Friend>) => void): void;
+    blockFriend(friendId: string): Promise<boolean>;
+}
+export {};

package/dist/pkg/api/features/friends/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pkg/api/features/nakama/nakama-provider.d.ts

@@ -0,0 +1,62 @@
+import { Client as NakamaClient, Session as NakamaSession, Socket as NakamaSocket } from '@heroiclabs/nakama-js';
+import { ApiEnv } from '../backend/backend.api';
+import { IHost } from '../host';
+import { Auth } from '../auth';
+import { ApiAccount } from '@heroiclabs/nakama-js/dist/api.gen';
+
+export declare type RpcGetNkUserByEagleIdParams = {
+    EagleUserId: string | number;
+};
+export declare type RpcGetNkUserByEagleUserNameParams = {
+    EagleUserName: string | number;
+};
+export interface RpcGetNkUserResponse {
+    CustomId: string;
+    UserId: string;
+    UserName: string;
+    message: string | null;
+}
+export interface NakamaContext {
+    client: NakamaClient | null;
+    session: NakamaSession | null;
+    socket: NakamaSocket | null;
+}
+export declare class NakamaProvider {
+    private host;
+    private auth;
+    private _ctx;
+    private _socketListeners;
+    private userSessionDeferred?;
+    private wasEagleSubscribed;
+    private env;
+    private gameId;
+    private _isConnected;
+    private RPC_GET_USER_BY_EAGLE_ID;
+    constructor(host: IHost, auth: Auth);
+    init(env: ApiEnv): void;
+    private getGameId;
+    isUserAuthorized(): boolean;
+    private getNakamaClient;
+    private subscribeToEagleAuthChanges;
+    private getNakamaVars;
+    private initNakamaSession;
+    private initNakamaSessionViaEagle;
+    /**
+     * this method is called when the user is logged in
+     * CAUTION: this method is called from eagle login status change, therefore it can't throw
+     */
+    private onEagleLogin;
+    /**
+     * this method is called when the user is logged out
+     * CAUTION: this method is called from eagle login status change, therefore it can't throw
+     */
+    private onEagleLogout;
+    getAccount(): Promise<ApiAccount | null>;
+    private isNakamaUserLinkedToEagle;
+    getContext(): NakamaContext;
+    rpcGetNkUserByEagleId(eagleId: string): Promise<RpcGetNkUserResponse | undefined>;
+    createSocket(): Promise<void>;
+    subscribeSocketListener(listener: (isConnected: boolean) => void): void;
+    private onSocketConnect;
+    private onSocketDisconnect;
+}

package/dist/pkg/api/features/nakama/nakama-provider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pkg/api/features/nakama/nakama-service.d.ts

@@ -0,0 +1,9 @@
+import { NakamaProvider, NakamaContext } from '../nakama/nakama-provider';
+
+export declare abstract class NakamaService {
+    protected _ctx: NakamaContext;
+    constructor(nakamaProvider: NakamaProvider);
+    isSupported(): boolean;
+    protected createSocket(): Promise<void>;
+    protected abstract onSocketConnectionChanged(isConnected: boolean): any;
+}

package/dist/pkg/api/features/notifications/index.d.ts

@@ -0,0 +1,41 @@
+import { NakamaProvider } from '../nakama/nakama-provider';
+import { NakamaService } from '../nakama/nakama-service';
+
+export declare const NOTIFICATION_TYPE_CHAT_INVITE: number;
+export declare const NOTIFICATION_TYPE_FRIEND_REQUEST: number;
+export declare const NOTIFICATION_TYPE_FRIEND_REQUEST_ACCEPTED: number;
+export declare enum NotificationType {
+    All = "all",
+    ChatInvite = "chat_invite",
+    FriendRequest = "friend_request",
+    FriendRequestAccepted = "friend_request_accepted"
+}
+export declare type Notification = {
+    type: NotificationType;
+    content?: {};
+    id?: string;
+    senderId?: string;
+    subject?: string;
+};
+export declare type GetNotificationParams = {
+    fromCache?: boolean;
+    limit?: number;
+};
+export declare type NotificationListener = (notification: Notification) => void;
+export declare type NotificationListenerRemover = () => void;
+export declare class NotificationsArena extends NakamaService {
+    private _notifications;
+    private _notificationListeners;
+    private _notificationCursor;
+    constructor(nakamaProvider: NakamaProvider);
+    getNotifications({ fromCache, limit }?: GetNotificationParams): Promise<Notification[]>;
+    deleteNotification(notificationId: string): Promise<boolean>;
+    private addNotificationToList;
+    private addNotificationsToList;
+    private removeNotificationFromList;
+    private mapNakamaNotificationToNotification;
+    private onNotificationReceived;
+    subscribeNotificationListener(listener: NotificationListener): NotificationListenerRemover;
+    subscribeNotificationTypeListener(listener: NotificationListener, type: NotificationType): NotificationListenerRemover;
+    protected onSocketConnectionChanged(isConnected: boolean): void;
+}

package/dist/pkg/arkadium-arena-sdk.d.ts

@@ -12,6 +12,9 @@ import { WalletArena } from './api/features/wallet';
 import { DebugProviderArena } from './api/core/debug-provider';
 import { SupportV1 } from './api/features/support-v1/support-v1';
 import { LeaderboardArena } from './api/features/leaderboard';
+import { FriendsArena } from './api/features/friends';
+import { NotificationsArena } from './api/features/notifications';
+import { ChatArena } from './api/features/chat';
 
 import * as MockUserUtils from './api/utils/mockUser';
 /** @hidden */
@@ -29,13 +32,16 @@ export declare class ArkadiumArenaSdk {
     debug: DebugProviderArena;
     private supportV1;
     private leaderboard;
+    friends: FriendsArena;
+    notifications: NotificationsArena;
+    chats: ChatArena;
     private currentEnv;
     private currentTarget;
     private gamePingSender;
     private gamePingListener;
     $pingNotification: Observable<number>;
     version: string;
-    constructor(rpcProvider: RpcProvider, backendApi: Backend, host: HostArena, lifecycle: GameLifecycleArena, ads: AdsArena, auth: AuthArena, analytics: AnalyticsApiContract, timeoutTester: TimeoutTesterContract, persistence: PersistenceArena, wallet: WalletArena, debug: DebugProviderArena, supportV1: SupportV1, leaderboard: LeaderboardArena);
+    constructor(rpcProvider: RpcProvider, backendApi: Backend, host: HostArena, lifecycle: GameLifecycleArena, ads: AdsArena, auth: AuthArena, analytics: AnalyticsApiContract, timeoutTester: TimeoutTesterContract, persistence: PersistenceArena, wallet: WalletArena, debug: DebugProviderArena, supportV1: SupportV1, leaderboard: LeaderboardArena, friends: FriendsArena, notifications: NotificationsArena, chats: ChatArena);
     setEnv(e: ApiEnv): void;
     initialize(env: ApiEnv, isGameSide: boolean, sessionStorage?: SessionStorageType | null): Promise<void>;
     private envDiscoverListener;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkadiuminc/sdk",
-  "version": "2.35.3",
+  "version": "2.36.1",
   "description": "",
   "keywords": [],
   "main": "dist/pkg/arkadium-sdk.umd.js",
@@ -96,6 +96,7 @@
     "vitest": "^1.4.0"
   },
   "dependencies": {
+    "@heroiclabs/nakama-js": "^2.8.0",
     "@microsoft/applicationinsights-web": "^3.0.4",
     "jsonpack": "^1.1.5",
     "nanoid": "^5.0.4",