@jolibox/sdk 1.1.4-beta.1 → 1.1.4-beta.11

package/src/api/__tests__/canIUse.test.ts

@@ -39,29 +39,29 @@ describe('canIUse', () => {
 
   it('should return true for supported API without properties', () => {
     mockGetCanIUseConfig.mockReturnValue({ version: '0.9.0' });
-    expect(canIUse('supportedApi')).toBe(true);
+    expect(canIUse('supportedApi')).toBe(false);
   });
 
   it('should check H5 platform configuration', () => {
     //eslint-disable-next-line @typescript-eslint/ban-ts-comment
     //@ts-ignore
     mockEnv.mockReturnValue({ data: { deviceInfo: { platform: 'h5' } } });
-    mockGetCanIUseConfig.mockReturnValue({ version: '0.9.0' });
-    expect(canIUse('webApi')).toBe(true);
+    mockGetCanIUseConfig.mockReturnValue({ version: '1.0.0' });
+    expect(canIUse('webApi')).toBe(false);
     expect(mockGetCanIUseConfig).toHaveBeenCalledWith('h5', 'webApi');
   });
 
   it('should handle nested property checks', () => {
     mockGetCanIUseConfig.mockReturnValue({
-      version: '0.9.0',
+      version: '1.0.0',
       properties: {
         feature: {
-          subFeature: '0.9.0'
+          subFeature: '1.0.0'
         }
       }
     });
 
-    expect(canIUse('api:feature:subFeature')).toBe(true);
+    expect(canIUse('api:feature:subFeature')).toBe(false);
   });
 
   it('should return false for unsupported property version', () => {

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

@@ -2,7 +2,7 @@ import { env as getEnv } from './get-system-info';
 import { isObject, isString, compareVersion } from '@jolibox/common';
 import { getCanIUseConfig, get } from '../utils/can-i-use';
 
-const __VERSION__ = '1.0.0'; // mock
+const __VERSION__ = '__JOLIBOX_LOCAL_SDK_VERSION__'; // mock
 
 export function canIUse(schema: string): boolean {
   const env = getEnv();

package/src/api/get-system-info.ts

@@ -1,9 +1,6 @@
 import { createCommands } from '@jolibox/common';
 
 const commands = createCommands();
-export async function getSystemInfo() {
-  return await commands.executeCommand('API.getSystemInfo');
-}
 
 export function getSystemInfoSync() {
   return commands.excuteCommandSync('API.getSystemInfoSync');

package/src/api/index.ts

@@ -1,2 +1,3 @@
 export * from './get-system-info';
 export * from './can-i-use';
+export * from './login';

package/src/api/login.ts

@@ -0,0 +1,24 @@
+import { createCommands } from '@jolibox/common';
+import { canIUse } from './can-i-use';
+import { ResponseType } from '@jolibox/types';
+
+const commands = createCommands();
+export async function login() {
+  if (!canIUse('login')) {
+    return {
+      code: 'FAILURE' as ResponseType,
+      message: '[Jolibox SDK]login is not supported in this platform'
+    };
+  }
+  return await commands.executeCommand('API.login');
+}
+
+export async function checkSession() {
+  if (!canIUse('checkSession')) {
+    return {
+      code: 'FAILURE' as ResponseType,
+      message: '[Jolibox SDK]checkSession is not supported in this platform'
+    };
+  }
+  return await commands.executeCommand('API.checkSession');
+}

package/src/events.ts

@@ -0,0 +1,82 @@
+import { hostEmitter, createCommands, BaseError, EProject } from '@jolibox/common';
+import { trackError } from './utils/event-tracker';
+document.addEventListener('DOMContentLoaded', () => hostEmitter.emit('onDocumentReady', timeline.startTime));
+
+const timelineFactory = () => {
+  let _beginLoad = 0;
+  return {
+    set startTime(time: number) {
+      _beginLoad = time;
+    },
+    get startTime(): number {
+      return _beginLoad;
+    }
+  };
+};
+
+export const timeline = timelineFactory();
+
+const commands = createCommands();
+
+const rejectHandler = (event: PromiseRejectionEvent | ErrorEvent | BaseError) => {
+  commands
+    .executeCommand('ReportSDK.traceSystem', {
+      event: 'globalJsError',
+      info: {
+        err: JSON.stringify(event)
+      }
+    })
+    .catch((e) => {
+      // 兜底上报
+      console.error(`Fallback report: ${e} ${JSON.stringify(event)}`);
+      trackError(
+        'globalJsError',
+        {
+          err: JSON.stringify({
+            message: e.message,
+            source: e.source,
+            lineno: e.lineno,
+            colno: e.colno,
+            error: e.error
+          })
+        },
+        EProject.WebSDK
+      );
+    });
+};
+
+export const reportError = rejectHandler;
+
+window.addEventListener('unhandledrejection', rejectHandler.bind(this));
+window.addEventListener('error', rejectHandler.bind(this));
+window.onerror = (message, source, lineno, colno, error) => {
+  commands
+    .executeCommand('ReportSDK.traceSystem', {
+      event: 'globalJsError',
+      info: {
+        err: JSON.stringify({
+          message,
+          source,
+          lineno,
+          colno,
+          error
+        })
+      }
+    })
+    .catch((e) => {
+      // 兜底上报
+      trackError(
+        'globalJsError',
+        {
+          err: JSON.stringify({
+            message,
+            source,
+            lineno,
+            colno,
+            error
+          })
+        },
+        EProject.WebSDK
+      );
+    });
+};

package/src/index.ts

@@ -2,28 +2,40 @@
 /**
  * global error catch
  */
-import './errors';
+import './events';
 import './loader';
 
 /**
  * @public Jolibox JS SDK Entry
  */
-import { getSystemInfo, getSystemInfoSync, canIUse } from './api';
+import { getSystemInfoSync, canIUse, login, checkSession } from './api';
 import { RuntimeSDK } from './sdks/runtime';
 import { LifecycleSDK } from './sdks/lifecycle';
 import { StorageSDK } from './sdks/storage';
 import { JoliboxAds } from './sdks/ads';
 import { KeyboardSDK } from './sdks/keyboard';
+import { TaskTrackerSDK } from './sdks/task';
+
+declare global {
+  interface Window {
+    JoliboxSDK: typeof JoliboxSDK; // TODO: code review this @Dengxue
+  }
+}
 
 export class JoliboxSDK {
+  readonly jssdkVersion = '__JOLIBOX_LOCAL_SDK_VERSION__';
   readonly runtime = new RuntimeSDK();
   readonly ads = new JoliboxAds();
   readonly lifecycle = new LifecycleSDK();
   readonly storage = new StorageSDK();
   readonly keyboard = new KeyboardSDK();
+  readonly task = new TaskTrackerSDK();
 
   //global API
-  getSystemInfo = getSystemInfo.bind(this);
   getSystemInfoSync = getSystemInfoSync.bind(this);
   canIUse = canIUse.bind(this);
+  login = login.bind(this);
+  checkSession = checkSession.bind(this);
 }
+
+window.JoliboxSDK = JoliboxSDK; // TODO: code review this @Dengxue

package/src/loader/h5.ts

@@ -2,7 +2,8 @@ import { compare, major } from './version';
 import { track, trackPerformance } from '../utils/report';
 import { InternalJSModuleEvalError, InternalJSModuleFetchError } from '@jolibox/common';
 import { getBoostrapModuleUrl, getImplementModuleUrl } from './index';
-import { reportError } from '../errors';
+import { reportError, timeline } from '../events';
+import { testMode } from '@/utils/env';
 
 const LOCAL_STORE_KEY = 'jolibox-sdk-loadermeta';
 interface LocalStoreMeta {
@@ -23,8 +24,8 @@ const expired = (now: number, prev: number) =>
 const isLegalScript = (str: string) =>
   !/^(Failed to fetch version|Couldn't find the requested file)/.test(str);
 async function fetchCurrentRemoteScript() {
-  // TODO: adjust host
-  const path = `https://stg-api.jolibox.com/api/fe-configs/js-sdk/version_metadata`;
+  const host = testMode ? 'https://stg-api.jolibox.com' : 'https://api.jolibox.com';
+  const path = `${host}/api/fe-configs/js-sdk/version_metadata`;
   try {
     const response = await fetch(path, {
       method: 'GET',
@@ -36,7 +37,7 @@ async function fetchCurrentRemoteScript() {
     let currentStore: LocalStoreMeta = { ...CURRENT_VERSION_STORE, timestamp: now };
     if (bootstrap_version) {
       const { bootstrap_version: currentLocalBootstrapVersion } = CURRENT_VERSION_STORE;
-      if (currentLocalBootstrapVersion && compare(currentLocalBootstrapVersion, bootstrap_version)) {
+      if (currentLocalBootstrapVersion && compare(currentLocalBootstrapVersion, bootstrap_version) >= 0) {
         // no-op
       } else {
         const currentBootstrapModuleStr = await (await fetch(getBoostrapModuleUrl(bootstrap_version))).text();
@@ -50,7 +51,7 @@ async function fetchCurrentRemoteScript() {
     }
     if (implement_version) {
       const { implement_version: currentLocalImpelementVersion } = CURRENT_VERSION_STORE;
-      if (currentLocalImpelementVersion && compare(currentLocalImpelementVersion, implement_version)) {
+      if (currentLocalImpelementVersion && compare(currentLocalImpelementVersion, implement_version) >= 0) {
         // no-op
       } else {
         const currentImplementModuleStr = await (
@@ -89,7 +90,7 @@ export const createLoadImplement = (params: {
       if (
         !expired(now, timestamp) &&
         major(bootstrap_version) == currentMajorVersion &&
-        compare(bootstrap_version, currentVersion) > 0
+        compare(bootstrap_version, currentVersion) >= 0
       ) {
         return { script: bootstrap_script, type: 'localscript' };
       }
@@ -106,9 +107,10 @@ export const createLoadImplement = (params: {
 
   function loadBootstrapModule() {
     const startToLoad = Date.now();
-    track('js_sdk_begin', {
+    track('jsSdkBegin', {
       t: startToLoad
     });
+    timeline.startTime = startToLoad;
 
     const { script: currentBootstrapModule, type } = fetchCurrentBootstrapModule() ?? {};
     if (currentBootstrapModule) {
@@ -136,7 +138,7 @@ export const createLoadImplement = (params: {
   }
 
   // load remote impletation
-  function loadRemoteImplementation() {
+  function loadRemoteImplement() {
     const implStartLoad = Date.now();
     const { implement_script, implement_version, timestamp } = CURRENT_VERSION_STORE;
     if (implement_script && implement_version && timestamp) {
@@ -146,7 +148,7 @@ export const createLoadImplement = (params: {
       if (
         !expired(now, timestamp) &&
         major(implement_version) == currentMajorVersion &&
-        compare(implement_version, currentVersion) > 0
+        compare(implement_version, currentVersion) >= 0
       ) {
         evalLocalJSModule(implement_script);
         trackPerformance('implementModuleLoaded', Date.now() - implStartLoad, { type: 'loadscript' });
@@ -166,7 +168,7 @@ export const createLoadImplement = (params: {
   return () => {
     try {
       loadBootstrapModule();
-      loadRemoteImplementation();
+      loadRemoteImplement();
       fetchCurrentRemoteScript();
     } catch (e) {
       reportError(new InternalJSModuleEvalError(`module evaluate error: ${e}`));

package/src/loader/index.ts

@@ -3,7 +3,7 @@ import { major } from './version';
 import { createLoadImplement as createH5LoadImplement } from './h5';
 import { createLoadImplement as createNativeLoadImplement } from './native';
 //TODO: temp
-const BUILD_VERSION = '1.0.0';
+const BUILD_VERSION = '__JOLIBOX_LOCAL_SDK_VERSION__';
 const currentVersion = BUILD_VERSION;
 const currentMajorVersion = major(currentVersion);
 
@@ -15,15 +15,27 @@ const currentMajorVersion = major(currentVersion);
 
 declare global {
   interface Window {
-    //   WebBridge: AndroidBridge | null;
+    JoliAndroidSDKBridge?: unknown;
     webkit?: unknown;
   }
 }
-const loadScript = window.webkit
-  ? (params: { path: string }) => {
-      return window.prompt('loadScript', JSON.stringify(params));
-    }
-  : undefined;
+const loadScript =
+  window.webkit || window.JoliAndroidSDKBridge
+    ? (params: { path: string }) => {
+        const res = window.prompt(
+          'invoke',
+          JSON.stringify({
+            event: 'loadScriptSync',
+            paramsString: JSON.stringify(params)
+          })
+        );
+        if (res) {
+          const { data } = JSON.parse(res);
+          return data;
+        }
+        return undefined;
+      }
+    : undefined;
 
 const isNative = typeof loadScript !== 'undefined';
 
@@ -32,16 +44,18 @@ const isNative = typeof loadScript !== 'undefined';
  * as this logic needs to remain self-contained within the SDK.
  */
 export const getBoostrapModuleUrl = (version: string | number) =>
-  `http://cdn.jsdelivr.net/npm/@jolibox/bootstrap@${version}/dist/index.js`;
+  `https://cdn.jsdelivr.net/npm/@jolibox/bootstrap@${version}/dist/index.js`;
 export const getImplementModuleUrl = (version: string | number) =>
-  `http://cdn.jsdelivr.net/npm/@jolibox/implementation@${version}/dist/index.js`;
-/**
- * localTest
- */
-// export const getBoostrapModuleUrl = (version: string | number) => `http://localhost:3000/get-bootstrap`;
-// export const getImplementModuleUrl = (version: string | number) => `http://localhost:3000/get-implement`;
-const IMMEDIATE_SCRIPT_URL = getBoostrapModuleUrl(currentMajorVersion);
-const REMOTE_IMPLEMENT_URL = getImplementModuleUrl(currentMajorVersion);
+  `https://cdn.jsdelivr.net/npm/@jolibox/implement@${version}/dist/index.js`;
+
+const checkReleaseVersion = (version: string): boolean => {
+  const semverRegex = /^\d+\.\d+\.\d+$/;
+  return semverRegex.test(version);
+};
+
+const fetchVersion = !checkReleaseVersion(currentVersion) ? currentVersion : currentMajorVersion;
+const IMMEDIATE_SCRIPT_URL = getBoostrapModuleUrl(fetchVersion);
+const REMOTE_IMPLEMENT_URL = getImplementModuleUrl(fetchVersion);
 
 /**
  * load entry

package/src/loader/native.ts

@@ -1,6 +1,6 @@
 import { track, trackPerformance } from '@/utils/report';
 import { InternalJSModuleEvalError } from '@jolibox/common';
-import { reportError } from '../errors';
+import { reportError, timeline } from '../events';
 
 export const createLoadImplement = (
   loadScript: (params: { path: string }) => string | null,
@@ -34,9 +34,10 @@ export const createLoadImplement = (
   return () => {
     try {
       const startToLoad = Date.now();
-      track('js_sdk_begin', {
+      track('jsSdkBegin', {
         t: startToLoad
       });
+      timeline.startTime = startToLoad;
       /**
        * bootstrap module
        */

package/src/sdks/keyboard.ts

@@ -8,14 +8,10 @@ export class KeyboardSDK extends BaseSDK implements Keyboard {
    * @returns
    */
   showKeyboard(params: { defaultValue?: string; maxLength?: number; multiple?: boolean }) {
-    const canUse = this.canUse('keyboard.showKeyboard');
-    if (!canUse) {
-      return {
-        code: 'FAILURE' as ResponseType,
-        message: `[Jolibox SDK] keyboard.showKeyboard is not supported in this platform`
-      };
+    const errMsg = this.canIUseIfThrow('keyboard.showKeyboard');
+    if (errMsg) {
+      return errMsg;
     }
-
     this.commands.executeCommand('KeyboardSDK.showKeyboard', params);
   }
   /**
@@ -24,26 +20,20 @@ export class KeyboardSDK extends BaseSDK implements Keyboard {
    * @returns
    */
   updateKeyboard(value: string) {
-    const canUse = this.canUse('keyboard.updateKeyboard');
-    if (!canUse) {
-      return {
-        code: 'FAILURE' as ResponseType,
-        message: `[Jolibox SDK] keyboard.updateKeyboard is not supported in this platform`
-      };
+    const errMsg = this.canIUseIfThrow('keyboard.updateKeyboard');
+    if (errMsg) {
+      return errMsg;
     }
-    this.commands.executeCommand('KeyboardSDK.updateKeyboard', value);
+    this.commands.executeCommand('KeyboardSDK.updateKeyboard', { value });
   }
   /**
    * 隐藏键盘
    * @returns
    */
   hideKeyboard() {
-    const canUse = this.canUse('keyboard.hideKeyboard');
-    if (!canUse) {
-      return {
-        code: 'FAILURE' as ResponseType,
-        message: `[Jolibox SDK] keyboard.hideKeyboard is not supported in this platform`
-      };
+    const errMsg = this.canIUseIfThrow('keyboard.hideKeyboard');
+    if (errMsg) {
+      return errMsg;
     }
     this.commands.executeCommand('KeyboardSDK.hideKeyboard');
   }

package/src/sdks/lifecycle.ts

@@ -19,14 +19,18 @@ export class LifecycleSDK extends BaseSDK<LifecycleSDKEventMap> implements Lifec
     this.commands.executeCommand('LifecycleSDK.onReady', wrappedOnReady.bind(this));
   }
 
-  exitGame(params: { onBeforeExit: () => void }) {
-    this.commands.executeCommand('LifecycleSDK.exitGame', params.onBeforeExit);
+  exit(params: { onBeforeExit: () => void }) {
+    const errMsg = this.canIUseIfThrow('lifeCycle.exit');
+    if (errMsg) {
+      return errMsg;
+    }
+    this.commands.executeCommand('LifecycleSDK.exit', params.onBeforeExit);
   }
 
-  onGameHide(params: () => void) {
-    this.commands.executeCommand('LifecycleSDK.onGameHide', params.bind(this));
+  onJoliboxHide(params: () => void) {
+    this.commands.executeCommand('LifecycleSDK.onJoliboxHide', params.bind(this));
   }
-  onGameShow(params: () => void) {
-    this.commands.executeCommand('LifecycleSDK.onGameShow', params.bind(this));
+  onJoliboxShow(params: () => void) {
+    this.commands.executeCommand('LifecycleSDK.onJoliboxShow', params.bind(this));
   }
 }

package/src/sdks/sdk.ts

@@ -1,5 +1,6 @@
 import { canIUse } from '@/api';
 import { createCommands, EventEmitter } from '@jolibox/common';
+import { ResponseType } from '@jolibox/types';
 export interface BaseSDKEventMap {
   _baseSDKMarker?: never;
 }
@@ -19,4 +20,13 @@ export abstract class BaseSDK<T = BaseSDKEventMap> {
   canUse(command: string) {
     return canIUse(command);
   }
+
+  canIUseIfThrow(command: string) {
+    if (!this.canUse(command)) {
+      return {
+        code: 'FAILURE' as ResponseType,
+        message: `[Jolibox SDK] ${command} is not supported in this platform`
+      };
+    }
+  }
 }

package/src/sdks/task.ts

@@ -0,0 +1,65 @@
+import { BaseSDK } from './sdk';
+import { TaskTracker, TaskResponse } from '@jolibox/types';
+
+export class TaskTrackerSDK extends BaseSDK implements TaskTracker {
+  async onLevelFinished(levelId: string | number, result: boolean, duration: number): Promise<TaskResponse> {
+    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 });
+  }
+  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;
+    }
+    return await this.commands.executeCommand('TaskTrackerSDK.taskEvent', taskId, params);
+  }
+  async onLevelUpgrade(levelId: string | number, name: string): Promise<TaskResponse> {
+    const errMsg = this.canIUseIfThrow('TaskTrackerSDK.onLevelUpgrade');
+    if (errMsg) {
+      return errMsg;
+    }
+    return await this.commands.executeCommand('TaskTrackerSDK.levelUpgrade', levelId, name);
+  }
+  async onHistoryUserLevel(level: number): Promise<TaskResponse> {
+    const errMsg = this.canIUseIfThrow('TaskTrackerSDK.onHistoryUserLevel');
+    if (errMsg) {
+      return errMsg;
+    }
+    return await this.commands.executeCommand('TaskTrackerSDK.historyUserLevel', level);
+  }
+  async onHistoryUserScore(score: number): Promise<TaskResponse> {
+    const errMsg = this.canIUseIfThrow('TaskTrackerSDK.onHistoryUserScore');
+    if (errMsg) {
+      return errMsg;
+    }
+    return await this.commands.executeCommand('TaskTrackerSDK.historyUserScore', score);
+  }
+}

package/src/utils/env.ts

@@ -0,0 +1 @@
+export const testMode = new URLSearchParams(window.location.search).get('joliboxEnv') === 'staging';