@arkadiuminc/sdk 2.11.0 → 2.13.0

package/dist/pkg/api/core/timeout-tester.d.ts

@@ -1,4 +1,5 @@
 import { RpcProvider } from './rpc';
+
 export interface TimeoutTesterContract {
     timeout(): Promise<void>;
 }

package/dist/pkg/api/features/ads/__mocks__/video-ad.d.ts

@@ -1,4 +1,5 @@
-import { ApiEnv } from "../../backend/backend.api";
+import { ApiEnv } from '../../backend/backend.api';
+
 export declare class VideoAd {
     static getInstance(): VideoAd;
     protected _scriptLoaded: Promise<void>;

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

@@ -1,6 +1,7 @@
 import { RpcProvider } from '../../core/rpc';
 import { ApiEnv } from '../backend/backend.api';
 import { Auth } from '../auth/';
+
 export interface GameAdsContract {
     showPrerollAd?(options: {
         duration?: number;

package/dist/pkg/api/features/ads/video-ad.d.ts

@@ -1,4 +1,5 @@
-import { ApiEnv } from "../backend/backend.api";
+import { ApiEnv } from '../backend/backend.api';
+
 export declare class VideoAd {
     static domain: string;
     static getInstance(domain?: string): VideoAd;

package/dist/pkg/api/features/analytics/analytics.api.d.ts

@@ -2,6 +2,7 @@ import { RpcProvider } from '../../core/rpc';
 import { AnalyticsProviderType, IAnalyticConfig } from './defs';
 import { DimensionsObject, Dimension } from './dimensions';
 import { IHost } from '../host';
+
 interface EnvironmentVersion {
     GameKey: string;
     GameVersion: string;

package/dist/pkg/api/features/analytics/providers/AnalyticsProvider.d.ts

@@ -1,5 +1,6 @@
-import { DimensionsObject } from "../dimensions";
+import { DimensionsObject } from '../dimensions';
 import { IAnalyticConfig } from '../defs';
+
 declare type EventArr = [string, string, DimensionsObject];
 declare type PageViewArr = [string, DimensionsObject];
 export declare abstract class AnalyticsProvider {
@@ -14,6 +15,6 @@ export declare abstract class AnalyticsProvider {
     sendEvent(eventCategory: string, eventAction: string, dimensions: DimensionsObject): void;
     sendPageView(pageName: string, dimensions: DimensionsObject): void;
     trackException(exception: Error): void;
-    getProviderType(): import("../defs").AnalyticsProviderType;
+    getProviderType(): import('../defs').AnalyticsProviderType;
 }
 export {};

package/dist/pkg/api/features/analytics/providers/AppInsightsProvider.d.ts

@@ -1,5 +1,6 @@
-import { DimensionsObject } from "../dimensions";
-import { AnalyticsProvider } from "./AnalyticsProvider";
+import { DimensionsObject } from '../dimensions';
+import { AnalyticsProvider } from './AnalyticsProvider';
+
 declare global {
     interface Window {
         Microsoft: {

package/dist/pkg/api/features/analytics/providers/ConsoleProvider.d.ts

@@ -1,5 +1,6 @@
-import { DimensionsObject } from "../dimensions";
-import { AnalyticsProvider } from "./AnalyticsProvider";
+import { DimensionsObject } from '../dimensions';
+import { AnalyticsProvider } from './AnalyticsProvider';
+
 /**
  * based on game-core-monorepo/packages/engine/src/Analytics/Provider/ConsoleAnalytic.ts
  */

package/dist/pkg/api/features/analytics/providers/GoogleTagManagerProvider.d.ts

@@ -1,5 +1,6 @@
-import { DimensionsObject, Dimension } from "../dimensions";
-import { AnalyticsProvider } from "./AnalyticsProvider";
+import { DimensionsObject, Dimension } from '../dimensions';
+import { AnalyticsProvider } from './AnalyticsProvider';
+
 /**
  * based on game-core-monorepo/packages/engine/src/Analytics/Provider/GoogleAnalytic.ts
  */

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

@@ -2,6 +2,7 @@ import { ApiEnv, Backend } from '../backend/backend.api';
 import { createStore } from '../../utils/observable';
 import { RpcProvider } from '../../core/rpc';
 import { IHost } from '../host';
+
 interface Image {
     png: string;
     webp: string;

package/dist/pkg/api/features/backend/backend.api.d.ts

@@ -1,5 +1,6 @@
 import { ApiGateway as UserApiGateway } from '@arkadium/eagle-user-client';
 import { UserGameDataApi } from '@arkadium/eagle-user-client/dist/types/api/v1/user-game-data.api';
+
 export declare enum ApiEnv {
     DEV = "DEV",
     PROD = "PROD",
@@ -13,15 +14,16 @@ export declare type SessionStorageType = ReturnType<typeof UserApiGateway.protot
 export declare class Backend {
     user: Awaited<ReturnType<typeof UserApiGateway.prototype.getAuthApi>> | null;
     private userGateway;
-    userGameData: UserGameDataApi | null;
-    uiOpenRequest: import("../../utils/observable").Observable<boolean>;
-    authStatus: import("../../utils/observable").Observable<boolean>;
+    private userGameData;
+    uiOpenRequest: import('../../utils/observable').Observable<boolean>;
+    authStatus: import('../../utils/observable').Observable<boolean>;
     addEventListener(event: number, cb: () => void): void;
     init(env: ApiEnv, isGameSide: boolean, sessionStorage?: SessionStorageType | null): Promise<void>;
     getAuthToken(): Promise<string> | undefined;
-    getSessionStorage(): import("@arkadium/eagle-user-client/dist/types/session-storage").SessionStorage | undefined;
+    getSessionStorage(): import('@arkadium/eagle-user-client/dist/types/session-storage').SessionStorage | undefined;
     checkAuth(): void;
     isUserAuthorized(): boolean;
     openAuthForm(): void;
     logout(): void;
+    getUserGameData(): UserGameDataApi | undefined;
 }

package/dist/pkg/api/features/game-lifecycle/game-lifecycle.api.d.ts

@@ -1,4 +1,5 @@
 import { RpcProvider } from '../../core/rpc';
+
 declare enum LifecycleEvent {
     TEST_READY = 1,
     GAME_START = 2,

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

@@ -1,4 +1,5 @@
 import { RpcProvider } from '../../core/rpc';
+
 export interface IHost {
     getQueryParameter(key: string): Promise<string | null>;
     getGameId(): Promise<string>;

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

@@ -1,12 +1,13 @@
 import { RpcProvider } from '../../core/rpc';
-import { NakamaProvider } from '../nakama/nakama-provider';
+import { Backend } from '../backend/backend.api';
 import { IHost } from '../host';
+
 declare type RemoteStorageValueType = string | object;
 export interface IPersistence {
+    getCookie(cookieName: string): Promise<string>;
     getLocalStorageItem(key: string): Promise<string | null>;
     setLocalStorageItem(key: string, value: string): Promise<void>;
     removeLocalStorageItem(key: string): Promise<void>;
-    getCookie(cookieName: string): Promise<string>;
     getRemoteStorageItem?(key: string): Promise<RemoteStorageValueType | null>;
     setRemoteStorageItem?(key: string, value: RemoteStorageValueType): Promise<void>;
     removeRemoteStorageItem?(key: string): Promise<boolean>;
@@ -17,24 +18,26 @@ export declare class PersistenceArena implements IPersistence {
      * @internal
      */
     constructor(rpcProvider: RpcProvider);
+    getCookie(cookieName: string): Promise<string>;
     getLocalStorageItem(key: string): Promise<string | null>;
     setLocalStorageItem(key: string, value: string): Promise<void>;
     removeLocalStorageItem(key: string): Promise<void>;
-    getCookie(cookieName: string): Promise<string>;
 }
 export declare class PersistenceGame implements IPersistence {
     private rpcProvider;
     private host;
+    private backend;
     private remoteStorageBlacklist;
     /**
      * @internal
      */
-    constructor(rpcProvider: RpcProvider, nakamaProvider: NakamaProvider, host: IHost);
+    constructor(rpcProvider: RpcProvider, host: IHost, backend: Backend);
+    getCookie(cookieName: string): Promise<string>;
     getLocalStorageItem(key: string): Promise<string | null>;
     setLocalStorageItem(key: string, value: string): Promise<void>;
     removeLocalStorageItem(key: string): Promise<void>;
-    getCookie(cookieName: string): Promise<string>;
-    private getRemoteStorageCollection;
+    private getCollection;
+    private getRemoteToLocalStorageCollection;
     private isRemoteStorageBlacklisted;
     getRemoteStorageItem(key: string): Promise<RemoteStorageValueType | null>;
     setRemoteStorageItem(key: string, value: RemoteStorageValueType): Promise<void>;

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

@@ -8,6 +8,7 @@ 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';
+
 export declare class ArkadiumGameSdk {
     private rpcProvider;
     backendApi: Backend;

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

@@ -2,12 +2,12 @@ import { ApiEnv, Backend, SessionStorageType } from './api/features/backend/back
 import { GameLifecycleContract } from './api/features/game-lifecycle/game-lifecycle.api';
 import { GameAdsContract } from './api/features/ads/';
 import { Auth } from './api/features/auth/';
-import { NakamaProvider } from './api/features/nakama/nakama-provider';
 import { AnalyticsApiContract } from './api/features/analytics/analytics.api';
 import { RpcProvider } from './api/core/rpc';
 import { TimeoutTesterContract } from './api/core/timeout-tester';
 import { PersistenceGame } from './api/features/persistence';
 import { HostGame } from './api/features/host';
+
 export declare class ArkadiumGameSdk {
     version: string;
     private currentEnv;
@@ -19,18 +19,16 @@ export declare class ArkadiumGameSdk {
     lifecycle: GameLifecycleContract;
     ads: GameAdsContract;
     auth: Auth;
-    private nakamaProvider;
     analytics: AnalyticsApiContract;
     private timeoutTester;
     persistence: PersistenceGame;
-    constructor({ rpcProvider, backendApi, host, lifecycle, ads, auth, nakamaProvider, analytics, timeoutTester, persistence }: {
+    constructor({ rpcProvider, backendApi, host, lifecycle, ads, auth, analytics, timeoutTester, persistence }: {
         rpcProvider: RpcProvider;
         backendApi: Backend;
         host: HostGame;
         lifecycle: GameLifecycleContract;
         ads: GameAdsContract;
         auth: Auth;
-        nakamaProvider?: NakamaProvider;
         analytics: AnalyticsApiContract;
         timeoutTester: TimeoutTesterContract;
         persistence: PersistenceGame;

package/dist/pkg/loader.d.ts

@@ -1,4 +1,5 @@
 import { ArkadiumGameSdk } from './arkadium-game-sdk';
+
 declare type API = ArkadiumGameSdk;
 export declare enum Env {
     DEV = "DEV",

package/dist/pkg/ping.module.d.ts

@@ -1,7 +1,8 @@
 import { RpcProvider } from './api/core/rpc';
+
 export declare class PingModule {
     constructor(rpcProvider: RpcProvider);
-    $ping: import("./api/utils/observable").Observable<number>;
+    $ping: import('./api/utils/observable').Observable<number>;
     ping(): boolean;
 }
 export declare class PingModuleProxy {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkadiuminc/sdk",
-  "version": "2.11.0",
+  "version": "2.13.0",
   "description": "",
   "keywords": [],
   "main": "dist/pkg/arkadium-sdk.umd.js",
@@ -95,7 +95,6 @@
     "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",

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

@@ -1,50 +0,0 @@
-import { Client as NakamaApiClient, Session as NakamaSession } from '@heroiclabs/nakama-js';
-import { ApiEnv, Backend } from '../backend/backend.api';
-import { IHost } from '../host';
-import { AnalyticsApiProxy } from '../analytics/analytics.api';
-import { Auth } from '../auth';
-interface NakamaProviderContract {
-    isUserAuthorized(): boolean;
-    getNakamaSession(): Promise<NakamaSession>;
-    getNakamaClient(): NakamaApiClient;
-}
-export declare class NakamaProvider implements NakamaProviderContract {
-    private backendApi;
-    private host;
-    private analytics;
-    private auth;
-    private nakamaApiClient;
-    private userSession?;
-    private userSessionDeferred?;
-    private wasEagleSubscribed;
-    private env;
-    private gameId;
-    constructor(backendApi: Backend, host: IHost, analytics: AnalyticsApiProxy, auth: Auth);
-    init(env: ApiEnv): void;
-    private getGameId;
-    isUserAuthorized(): boolean;
-    getNakamaClient(): NakamaApiClient;
-    /**
-     * this method authenticates the user if no session exists or if it is unsuited to proceed
-     */
-    getNakamaSession(): Promise<NakamaSession>;
-    private getClientAndSession;
-    private isNakamaUserLinkedToEagle;
-    private getNakamaVars;
-    private initNakamaSession;
-    private initNakamaSessionViaFingerprint;
-    private initNakamaSessionViaEagle;
-    private onAuthBootstrap;
-    /**
-     * 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;
-    private getAccount;
-}
-export {};

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

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