@jolibox/sdk 1.1.25 → 1.1.27

package/dist/sdks/storage.d.ts

@@ -1,8 +1,8 @@
 import { BaseSDK } from './sdk';
 import { StandardResponse, Storage } from '@jolibox/types';
 export declare class StorageSDK extends BaseSDK implements Storage {
-    getItem(key: string): Promise<StandardResponse<string | null>>;
+    getItem(key: string): Promise<StandardResponse<string | null, unknown>>;
     setItem(key: string, value: number | string | boolean): Promise<StandardResponse<void>>;
-    removeItem(key: string): Promise<StandardResponse<void>>;
-    clear(): Promise<StandardResponse<void>>;
+    removeItem(key: string): Promise<StandardResponse<void, unknown>>;
+    clear(): Promise<StandardResponse<void, unknown>>;
 }

package/dist/sdks/task.d.ts

@@ -1,25 +1,49 @@
 import { BaseSDK } from './sdk';
 import { TaskTracker, TaskResponse } from '@jolibox/types';
 export declare class TaskTrackerSDK extends BaseSDK implements TaskTracker {
-    onLevelFinished(levelId: string | number, result: boolean, duration: number): Promise<TaskResponse>;
-    onTaskFinished(taskId: string | number, duration: number): Promise<TaskResponse>;
-    onTaskEvent(taskId: string | number, params: {
-        tools?: {
-            id: string | number;
-            name: string;
-            count?: number;
-            description?: string;
-            price?: {
-                amount: number;
-                unit: string;
-            };
-        }[];
-        awards?: {
-            id: string | number;
-            name: string;
-        }[];
+    /**
+     * Handles completion of a game level by sending analytics data to the backend
+     *
+     * @param params - Object containing level completion details:
+     * @param params.levelId - Unique identifier for the completed level (string or number)
+     * @param params.duration - Optional time spent in the level (milliseconds)
+     * @param params.rating - Optional user rating for the level
+     * @param params.score - Optional final score achieved in the level
+     * @returns Promise resolving to TaskResponse or error message if validation fails
+     * @throws {Promise} Rejects with error if params is not an object
+     */
+    onLevelFinished(params: {
+        levelId: string | number;
+        duration?: number;
+        rating?: number;
+        score?: number;
+    }): Promise<TaskResponse>;
+    /**
+     * Records completion of a gameplay session with final metrics
+     *
+     * @param params - Object containing gameplay session details:
+     * @param params.duration - Optional total time spent in gameplay (milliseconds)
+     * @param params.rating - Optional user rating for the gameplay session
+     * @param params.score - Mandatory final score achieved during gameplay
+     * @returns Promise resolving to TaskResponse or error message if validation fails
+     * @throws {Promise} Rejects with error if params is not an object
+     */
+    onGamePlayEnded(params: {
+        duration?: number;
+        rating?: number;
+        score: number;
+    }): Promise<TaskResponse>;
+    /**
+     * Tracks player progression when they upgrade to a new level
+     *
+     * @param params - Object containing level upgrade details:
+     * @param params.levelId - Unique identifier for the new level (string or number)
+     * @param params.name - Optional display name for the upgraded level
+     * @returns Promise resolving to TaskResponse or error message if validation fails
+     * @throws {Promise} Rejects with error if params is not an object
+     */
+    onLevelUpgrade(params: {
+        levelId: string | number;
+        name?: string;
     }): Promise<TaskResponse>;
-    onLevelUpgrade(levelId: string | number, name: string): Promise<TaskResponse>;
-    onHistoryUserLevel(level: number): Promise<TaskResponse>;
-    onHistoryUserScore(score: number): Promise<TaskResponse>;
 }

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@jolibox/sdk",
   "description": "This project is common Jolibox JS-SDk interfere",
-  "version": "1.1.25",
+  "version": "1.1.27",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",
   "typings": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "@jolibox/common": "1.1.25",
-    "@jolibox/types": "1.1.25"
+    "@jolibox/common": "1.1.27",
+    "@jolibox/types": "1.1.27"
   },
   "devDependencies": {
     "typescript": "5.7.3",

package/sdk.build.log

@@ -1,17 +1,17 @@
 Invoking: npm run clean && npm run build:cjs && npm run build:esm && npm run build:iife && tsc 
 
-> @jolibox/sdk@1.1.25 clean
+> @jolibox/sdk@1.1.27 clean
 > rimraf ./dist
 
 
-> @jolibox/sdk@1.1.25 build:cjs
+> @jolibox/sdk@1.1.27 build:cjs
 > BUILD_VERSION=$(node -p "require('./package.json').version")  node esbuild.config.js --format=cjs
 
 
-> @jolibox/sdk@1.1.25 build:esm
+> @jolibox/sdk@1.1.27 build:esm
 > BUILD_VERSION=$(node -p "require('./package.json').version")  node esbuild.config.js --format=esm
 
 
-> @jolibox/sdk@1.1.25 build:iife
+> @jolibox/sdk@1.1.27 build:iife
 > BUILD_VERSION=$(node -p "require('./package.json').version")  node esbuild.config.js --format=iife
 

package/src/api/can-i-use.ts

@@ -1,19 +1,12 @@
-import { env as getEnv } from './get-system-info';
-import { isObject, isString, compareVersion } from '@jolibox/common';
+import { isObject, isString, compareVersion, isNative } from '@jolibox/common';
 import { getCanIUseConfig, get } from '../utils/can-i-use';
 
 const __VERSION__ = '__JOLIBOX_LOCAL_SDK_VERSION__'; // mock
 
 export function canIUse(schema: string): boolean {
-  const env = getEnv();
-  const platform = env.data?.deviceInfo?.platform;
-  if (!platform) {
-    return false;
-  }
-
   const [name, ...rest] = schema.split(':');
 
-  const api = getCanIUseConfig(platform == 'h5' ? platform : 'native', name);
+  const api = getCanIUseConfig(isNative() ? 'native' : 'h5', name);
 
   if (!api) return false;
 

package/src/sdks/task.ts

@@ -1,65 +1,91 @@
 import { BaseSDK } from './sdk';
-import { TaskTracker, TaskResponse } from '@jolibox/types';
+import { TaskTracker, TaskResponse, type ResponseType } from '@jolibox/types';
 
 export class TaskTrackerSDK extends BaseSDK implements TaskTracker {
-  async onLevelFinished(levelId: string | number, result: boolean, duration: number): Promise<TaskResponse> {
+  /**
+   * Handles completion of a game level by sending analytics data to the backend
+   *
+   * @param params - Object containing level completion details:
+   * @param params.levelId - Unique identifier for the completed level (string or number)
+   * @param params.duration - Optional time spent in the level (milliseconds)
+   * @param params.rating - Optional user rating for the level
+   * @param params.score - Optional final score achieved in the level
+   * @returns Promise resolving to TaskResponse or error message if validation fails
+   * @throws {Promise} Rejects with error if params is not an object
+   */
+  async onLevelFinished(params: {
+    levelId: string | number;
+    duration?: number;
+    rating?: number;
+    score?: number;
+  }): Promise<TaskResponse> {
+    if (typeof params !== 'object') {
+      return Promise.reject({ code: 'FAILURE' as ResponseType, message: 'params must be an object' });
+    }
+    const { levelId, duration, rating, score } = params;
     const errMsg = this.canIUseIfThrow('TaskTrackerSDK.onLevelFinished');
     if (errMsg) {
       return Promise.resolve(errMsg);
     }
-    return await this.commands.executeCommand('TaskTrackerSDK.levelFinished', levelId, { result, duration });
-  }
-  async onTaskFinished(taskId: string | number, duration: number): Promise<TaskResponse> {
-    const errMsg = this.canIUseIfThrow('TaskTrackerSDK.onTaskFinished');
-    if (errMsg) {
-      return errMsg;
-    }
-    return await this.commands.executeCommand('TaskTrackerSDK.taskFinished', taskId, { duration });
+    return await this.commands.executeCommand('TaskTrackerSDK.levelFinished', {
+      levelId,
+      duration,
+      rating,
+      score
+    });
   }
-  async onTaskEvent(
-    taskId: string | number,
-    params: {
-      tools?: {
-        id: string | number;
-        name: string;
-        count?: number;
-        description?: string;
-        price?: {
-          amount: number;
-          unit: string;
-        };
-      }[];
-      awards?: {
-        id: string | number;
-        name: string;
-      }[];
-    }
-  ): Promise<TaskResponse> {
-    const errMsg = this.canIUseIfThrow('TaskTrackerSDK.onTaskEvent');
-    if (errMsg) {
-      return errMsg;
+
+  /**
+   * Records completion of a gameplay session with final metrics
+   *
+   * @param params - Object containing gameplay session details:
+   * @param params.duration - Optional total time spent in gameplay (milliseconds)
+   * @param params.rating - Optional user rating for the gameplay session
+   * @param params.score - Mandatory final score achieved during gameplay
+   * @returns Promise resolving to TaskResponse or error message if validation fails
+   * @throws {Promise} Rejects with error if params is not an object
+   */
+  async onGamePlayEnded(params: {
+    duration?: number;
+    rating?: number;
+    score: number;
+  }): Promise<TaskResponse> {
+    if (typeof params !== 'object') {
+      return Promise.reject({ code: 'FAILURE' as ResponseType, message: 'params must be an object' });
     }
-    return await this.commands.executeCommand('TaskTrackerSDK.taskEvent', taskId, params);
-  }
-  async onLevelUpgrade(levelId: string | number, name: string): Promise<TaskResponse> {
-    const errMsg = this.canIUseIfThrow('TaskTrackerSDK.onLevelUpgrade');
+    const { duration, rating, score } = params;
+    const errMsg = this.canIUseIfThrow('TaskTrackerSDK.onGamePlayEnded');
     if (errMsg) {
-      return errMsg;
+      return Promise.resolve(errMsg);
     }
-    return await this.commands.executeCommand('TaskTrackerSDK.levelUpgrade', levelId, name);
+    return await this.commands.executeCommand('TaskTrackerSDK.gamePlayEnded', {
+      duration,
+      rating,
+      score
+    });
   }
-  async onHistoryUserLevel(level: number): Promise<TaskResponse> {
-    const errMsg = this.canIUseIfThrow('TaskTrackerSDK.onHistoryUserLevel');
-    if (errMsg) {
-      return errMsg;
+
+  /**
+   * Tracks player progression when they upgrade to a new level
+   *
+   * @param params - Object containing level upgrade details:
+   * @param params.levelId - Unique identifier for the new level (string or number)
+   * @param params.name - Optional display name for the upgraded level
+   * @returns Promise resolving to TaskResponse or error message if validation fails
+   * @throws {Promise} Rejects with error if params is not an object
+   */
+  async onLevelUpgrade(params: { levelId: string | number; name?: string }): Promise<TaskResponse> {
+    if (typeof params !== 'object') {
+      return Promise.reject({ code: 'FAILURE' as ResponseType, message: 'params must be an object' });
     }
-    return await this.commands.executeCommand('TaskTrackerSDK.historyUserLevel', level);
-  }
-  async onHistoryUserScore(score: number): Promise<TaskResponse> {
-    const errMsg = this.canIUseIfThrow('TaskTrackerSDK.onHistoryUserScore');
+    const { levelId, name } = params;
+    const errMsg = this.canIUseIfThrow('TaskTrackerSDK.onLevelUpgrade');
     if (errMsg) {
       return errMsg;
     }
-    return await this.commands.executeCommand('TaskTrackerSDK.historyUserScore', score);
+    return await this.commands.executeCommand('TaskTrackerSDK.levelUpgrade', {
+      levelId,
+      name
+    });
   }
 }