@arkadiuminc/sdk 2.23.0 → 2.24.0

package/dist/pkg/api/core/debug-provider.d.ts

@@ -0,0 +1,23 @@
+import { RpcProvider } from './rpc';
+import { ObserverFn } from '../utils/observable';
+
+export interface DebugProvider {
+    setDebugMode?(isEnabled: boolean): void;
+    sendDebugEvent(type: string, ...args: any[]): void;
+    onDebugEvent?(observer: any): void;
+}
+export declare class DebugProviderArena implements DebugProvider {
+    private observers;
+    private isDebug;
+    constructor(rpcProvider: RpcProvider);
+    private initDebugMode;
+    private isDebugMode;
+    setDebugMode(isEnabled: boolean): void;
+    sendDebugEvent(type: string, ...args: any[]): void;
+    onDebugEvent(observer: ObserverFn<string>): void;
+}
+export declare class DebugProviderGame implements DebugProvider {
+    private rpcProvider;
+    constructor(rpcProvider: RpcProvider);
+    sendDebugEvent(type: string, ...args: any[]): void;
+}

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

@@ -28,30 +28,24 @@ interface AuthUIManagerContract {
     openAuthRequest: ReturnType<typeof createStore<boolean>>;
     openAuthForm(): Promise<void>;
 }
-export declare class Auth {
-    private userProfileReader;
-    private authUIManager;
-    private authProblem;
-    constructor(userProfileReader: UserProfileReaderContract, authUIManager: AuthUIManagerContract);
+export declare abstract class Auth {
+    protected userProfileReader: UserProfileReaderContract;
+    protected authUIManager: AuthUIManagerContract | undefined;
+    constructor(backendApi: Backend, host: IHost);
     init(): Promise<void>;
     isUserAuthorized(): Promise<boolean>;
-    getUserProfile(): Promise<UserProfile | null>;
+    abstract getUserProfile(): Promise<UserProfile | null>;
     onAuthStatusChange(observer: any): () => void;
     openAuthForm(): Promise<void>;
-    /**
-     * this method should be exercised on the game side to let game know about
-     * issues that happen during auth outside the scope of direct API calls
-     */
-    onAuthProblemChange(observer: any): Promise<void>;
-    /**
-     * this method should be internally called every time a problem happens
-     * outside the scope of direct API calls
-     * @private
-     * @param error string
-     */
-    raiseOnAuthProblem(error: string): void;
-    onOpenAuthForm(observer: any): () => void;
-    static getArenaApi(backendApi: Backend, host: IHost, rpcProvider: RpcProvider): Auth;
-    static getGameApi(backendApi: Backend, host: IHost, rpcProvider: RpcProvider): Auth;
+    onOpenAuthForm(observer: any): (() => void) | undefined;
+}
+export declare class AuthArena extends Auth {
+    constructor(backendApi: Backend, host: IHost, rpcProvider: RpcProvider);
+    getUserProfile(): Promise<UserProfile | null>;
+}
+export declare class AuthGame extends Auth {
+    private rpcProvider;
+    constructor(backendApi: Backend, host: IHost, rpcProvider: RpcProvider);
+    getUserProfile(): Promise<UserProfile | null>;
 }
 export {};

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

@@ -1,6 +1,7 @@
 import { RpcProvider } from '../../core/rpc';
 import { Backend } from '../backend/backend.api';
 import { IHost } from '../host';
+import { DebugProvider } from '../../core/debug-provider';
 
 declare type RemoteStorageValueType = string | object;
 export interface IPersistence {
@@ -14,11 +15,12 @@ export interface IPersistence {
 }
 /** @hidden */
 export declare class PersistenceArena implements IPersistence {
+    private debugProvider;
     private ls;
     /**
      * @internal
      */
-    constructor(rpcProvider: RpcProvider);
+    constructor(rpcProvider: RpcProvider, debugProvider: DebugProvider);
     getCookie(cookieName: string): Promise<string>;
     getLocalStorageItem(key: string): Promise<string | null>;
     setLocalStorageItem(key: string, value: string): Promise<void>;
@@ -28,11 +30,12 @@ export declare class PersistenceGame implements IPersistence {
     private rpcProvider;
     private host;
     private backend;
+    private debugProvider;
     private remoteStorageBlacklist;
     /**
      * @internal
      */
-    constructor(rpcProvider: RpcProvider, host: IHost, backend: Backend);
+    constructor(rpcProvider: RpcProvider, host: IHost, backend: Backend, debugProvider: DebugProvider);
     getCookie(cookieName: string): Promise<string>;
     private getPrefixedLocalStorageKey;
     getLocalStorageItem(key: string): Promise<string | null>;

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

@@ -1,19 +1,20 @@
 import { ApiEnv, Backend } from '../backend/backend.api';
 import { GameLifecycleContract } from '../game-lifecycle/game-lifecycle.api';
+import { RpcProvider } from '../../core/rpc';
 
 export interface Wallet {
-    init(env: ApiEnv): Promise<void>;
+    init?(env: ApiEnv): Promise<void>;
     getGems(): Promise<number>;
     consumeGems(amount: number): Promise<boolean>;
 }
-export declare class WalletGame implements Wallet {
+export declare class WalletArena implements Wallet {
     private backendApi;
     private lifecycle;
     private virtualItemsApi;
     private virtualItemGateway;
     private currencySku;
     private isInited;
-    constructor(backendApi: Backend, lifecycle: GameLifecycleContract);
+    constructor(backendApi: Backend, lifecycle: GameLifecycleContract, rpcProvider: RpcProvider);
     init(env: ApiEnv): Promise<void>;
     /**
      * Allows querying for the wallet balance
@@ -27,3 +28,18 @@ export declare class WalletGame implements Wallet {
      */
     consumeGems(amount: number): Promise<boolean>;
 }
+export declare class WalletGame implements Wallet {
+    private rpcProvider;
+    constructor(rpcProvider: RpcProvider);
+    /**
+     * Allows querying for the wallet balance
+     * @returns the amount of gems in the user wallet
+     */
+    getGems(): Promise<number>;
+    /**
+     * Consumes the desired amount of gems from the user wallet
+     * @param amount
+     * @returns true if the spending of the gem amount was successful, false otherwise
+     */
+    consumeGems(amount: number): Promise<boolean>;
+}

package/dist/pkg/api/utils/mockUser.d.ts

@@ -0,0 +1,27 @@
+interface Image {
+    png: string;
+    webp: string;
+}
+interface UserProfile {
+    uid: string;
+    username: string;
+    avatar: Image;
+    avatarFrame?: Image;
+    avatarBackground?: string;
+    isUserSubscriber: boolean;
+    aarpMembershipStatus?: boolean;
+    coins?: number;
+    level?: number;
+}
+export declare type MockUser = {
+    profile: UserProfile;
+    wallet: {
+        getGems: () => number;
+        consumeGems: (amount: number) => boolean;
+    };
+};
+export declare function getMockUserEnabled(): boolean;
+export declare function setMockUserEnabled(enabled: boolean): void;
+export declare function getMockUser(): MockUser | undefined;
+export declare function setMockUser(user: MockUser): void;
+export {};

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

@@ -2,13 +2,16 @@ import { ApiEnv, Backend, SessionStorageType } from './api/features/backend/back
 import { GameLifecycleContract } from './api/features/game-lifecycle/game-lifecycle.api';
 import { RpcProvider } from './api/core/rpc';
 import { AdsArena } from './api/features/ads/';
-import { Auth } from './api/features/auth/';
+import { AuthArena } from './api/features/auth/';
 import { AnalyticsApiContract } from './api/features/analytics/analytics.api';
 import { Observable } from './api/utils/observable';
 import { TimeoutTesterContract } from './api/core/timeout-tester';
 import { PersistenceArena } from './api/features/persistence';
 import { HostArena } from './api/features/host';
+import { WalletArena } from './api/features/wallet';
+import { DebugProviderArena } from './api/core/debug-provider';
 
+import * as MockUserUtils from './api/utils/mockUser';
 /** @hidden */
 export declare class ArkadiumArenaSdk {
     private rpcProvider;
@@ -16,24 +19,30 @@ export declare class ArkadiumArenaSdk {
     host: HostArena;
     lifecycle: GameLifecycleContract;
     ads: AdsArena;
-    auth: Auth;
+    auth: AuthArena;
     analytics: AnalyticsApiContract;
     private timeoutTester;
     persistence: PersistenceArena;
+    private wallet;
+    debug: DebugProviderArena;
     private currentEnv;
     private currentTarget;
     private gamePingSender;
     private gamePingListener;
     $pingNotification: Observable<number>;
     version: string;
-    constructor(rpcProvider: RpcProvider, backendApi: Backend, host: HostArena, lifecycle: GameLifecycleContract, ads: AdsArena, auth: Auth, analytics: AnalyticsApiContract, timeoutTester: TimeoutTesterContract, persistence: PersistenceArena);
+    constructor(rpcProvider: RpcProvider, backendApi: Backend, host: HostArena, lifecycle: GameLifecycleContract, ads: AdsArena, auth: AuthArena, analytics: AnalyticsApiContract, timeoutTester: TimeoutTesterContract, persistence: PersistenceArena, wallet: WalletArena, debug: DebugProviderArena);
     setEnv(e: ApiEnv): void;
     initialize(env: ApiEnv, isGameSide: boolean, sessionStorage?: SessionStorageType | null): Promise<void>;
     private envDiscoverListener;
     updateWinReference(target: any): void;
-    debugMode(enabled: boolean): void;
+    debugMode(isEnabled: boolean): void;
     ping(): Promise<any>;
     dispose(): void;
+    setMockUserConfig({ isEnabled, mockUser }: {
+        isEnabled: boolean;
+        mockUser: MockUserUtils.MockUser;
+    }): void;
 }
 export { ApiEnv };
 /** @hidden */

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

@@ -1,7 +1,7 @@
 import { ApiEnv, Backend } from './api/features/backend/backend.api';
 import { GameLifecycleContract } from './api/features/game-lifecycle/game-lifecycle.api';
 import { AdsGame } from './api/features/ads/';
-import { Auth } from './api/features/auth/';
+import { AuthGame } from './api/features/auth/';
 import { AnalyticsApiContract } from './api/features/analytics/analytics.api';
 import { RpcProvider } from './api/core/rpc';
 import { TimeoutTesterContract } from './api/core/timeout-tester';
@@ -19,7 +19,7 @@ export declare class ArkadiumGameSdk {
     host: HostGame;
     lifecycle: GameLifecycleContract;
     ads: AdsGame;
-    auth: Auth;
+    auth: AuthGame;
     analytics: AnalyticsApiContract;
     private timeoutTester;
     persistence: PersistenceGame;
@@ -30,7 +30,7 @@ export declare class ArkadiumGameSdk {
         host: HostGame;
         lifecycle: GameLifecycleContract;
         ads: AdsGame;
-        auth: Auth;
+        auth: AuthGame;
         analytics: AnalyticsApiContract;
         timeoutTester: TimeoutTesterContract;
         persistence: PersistenceGame;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkadiuminc/sdk",
-  "version": "2.23.0",
+  "version": "2.24.0",
   "description": "",
   "keywords": [],
   "main": "dist/pkg/arkadium-sdk.umd.js",