@jolibox/sdk 1.1.12 → 1.1.13-beta.1

package/dist/loader/__tests__/local-storage.test.d.ts

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

package/dist/loader/__tests__/localstorage-protector.d.ts

@@ -0,0 +1,14 @@
+type StorageIsolationOptions = {
+    namespace?: string;
+    debug?: boolean;
+};
+declare global {
+    interface Window {
+        __joliboxLocalStorage__: typeof window.localStorage;
+    }
+}
+export declare function createStorageIsolation(options?: StorageIsolationOptions): {
+    isolateFrame: (frame: HTMLIFrameElement) => void;
+    isolateWindowStorage: () => void;
+};
+export {};

package/dist/loader/local-storage.d.ts

@@ -0,0 +1 @@
+export declare function getOriginalLocalStorage(): Storage;

package/dist/sdks/lifecycle.d.ts

@@ -9,6 +9,7 @@ export declare class LifecycleSDK extends BaseSDK<LifecycleSDKEventMap> implemen
     onReady(callback: (info?: Env['hostUserInfo']) => void): void;
     exit(params: {
         onBeforeExit: () => void;
+        shouldStay?: boolean;
     }): {
         code: import("@jolibox/types").ResponseType;
         message: string;

package/dist/sdks/router.d.ts

@@ -0,0 +1,15 @@
+import { BaseSDK } from './sdk';
+import { Router, ResponseType, StandardResponse } from '@jolibox/types';
+export declare class RouterSDK extends BaseSDK implements Router {
+    openSchema(schema: string): Promise<{
+        code: ResponseType;
+        message: string;
+    }>;
+    openPage(url: string): Promise<StandardResponse<{
+        webviewId: number;
+    }>>;
+    closePage(webviewId: number): Promise<{
+        code: ResponseType;
+        message: string;
+    }>;
+}

package/esbuild.config.js

@@ -1,5 +1,6 @@
 const esbuild = require('esbuild');
 const fs = require('fs');
+const babel = require('@babel/core');
 
 function versionPlugin(version) {
   return {
@@ -52,9 +53,34 @@ function build(format) {
           '.js': 'jsx'
         },
         plugins: [versionPlugin(process.env.BUILD_VERSION || '1.0.0')],
+        inject: ['../../polyfills/abort-controller-polyfill.js'],
       }); 
 }
 
+// Step 1: Bundle with esbuild
+esbuild.buildSync({
+  entryPoints: ['src/index.js'],
+  bundle: true,
+  outfile: 'dist/temp.js',
+  format: 'iife',
+});
+
+// Step 2: Transform with Babel
+const code = fs.readFileSync('dist/temp.js', 'utf8');
+const result = babel.transformSync(code, {
+  presets: [
+    ['@babel/preset-env', {
+      targets: {
+        safari: '14'
+      }
+    }]
+  ]
+});
+
+// Write the final output
+fs.writeFileSync('dist/index.js', result.code);
+fs.unlinkSync('dist/temp.js'); // Clean up temp file
+
 (async ()=>{
     try{
         await build(options.format);

package/package.json

@@ -1,21 +1,24 @@
 {
   "name": "@jolibox/sdk",
   "description": "This project is common Jolibox JS-SDk interfere",
-  "version": "1.1.12",
+  "version": "1.1.13-beta.1",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",
   "typings": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "@jolibox/common": "1.1.12",
-    "@jolibox/types": "1.1.12"
+    "@jolibox/common": "1.1.13-beta.1",
+    "@jolibox/types": "1.1.13-beta.1"
   },
   "devDependencies": {
     "typescript": "5.7.3",
     "@jolibox/eslint-config": "1.0.0",
     "@types/jest": "28.1.1",
     "rimraf": "6.0.1",
-    "esbuild": "0.24.2"
+    "esbuild": "0.24.2",
+    "@babel/core": "7.23.3",
+    "@babel/preset-env": "7.23.3",
+    "@babel/preset-typescript": "7.23.3"
   },
   "scripts": {
     "clean": "rimraf ./dist",

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.12 clean
+> @jolibox/sdk@1.1.13-beta.1 clean
 > rimraf ./dist
 
 
-> @jolibox/sdk@1.1.12 build:cjs
+> @jolibox/sdk@1.1.13-beta.1 build:cjs
 > BUILD_VERSION=$(node -p "require('./package.json').version")  node esbuild.config.js --format=cjs
 
 
-> @jolibox/sdk@1.1.12 build:esm
+> @jolibox/sdk@1.1.13-beta.1 build:esm
 > BUILD_VERSION=$(node -p "require('./package.json').version")  node esbuild.config.js --format=esm
 
 
-> @jolibox/sdk@1.1.12 build:iife
+> @jolibox/sdk@1.1.13-beta.1 build:iife
 > BUILD_VERSION=$(node -p "require('./package.json').version")  node esbuild.config.js --format=iife
 

package/src/api/index.ts

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

package/src/api/request.ts

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

package/src/index.ts

@@ -8,13 +8,14 @@ import './loader';
 /**
  * @public Jolibox JS SDK Entry
  */
-import { getSystemInfoSync, canIUse, login, checkSession } from './api';
+import { getSystemInfoSync, canIUse, login, checkSession, request } 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';
+import { RouterSDK } from './sdks/router';
 
 declare global {
   interface Window {
@@ -26,6 +27,7 @@ declare global {
       storage: InstanceType<typeof StorageSDK>;
       keyboard: InstanceType<typeof KeyboardSDK>;
       task: InstanceType<typeof TaskTrackerSDK>;
+      router: InstanceType<typeof RouterSDK>;
     };
   }
 }
@@ -38,12 +40,14 @@ export class JoliboxSDK {
   readonly storage = new StorageSDK();
   readonly keyboard = new KeyboardSDK();
   readonly task = new TaskTrackerSDK();
+  readonly router = new RouterSDK();
 
   //global API
   getSystemInfoSync = getSystemInfoSync.bind(this);
   canIUse = canIUse.bind(this);
   login = login.bind(this);
   checkSession = checkSession.bind(this);
+  request = request.bind(this);
 
   constructor() {
     window.joliboxsdk = {
@@ -52,7 +56,8 @@ export class JoliboxSDK {
       lifecycle: this.lifecycle,
       storage: this.storage,
       keyboard: this.keyboard,
-      task: this.task
+      task: this.task,
+      router: this.router
     };
   }
 }

package/src/loader/__tests__/local-storage.test.ts

@@ -0,0 +1,36 @@
+import { createStorageIsolation } from './localstorage-protector';
+import { getOriginalLocalStorage } from '../local-storage';
+
+createStorageIsolation({
+  namespace: 'jolibox-sdk-test'
+});
+
+describe('getOriginalLocalStorage', () => {
+  it('should return localStorage object', () => {
+    const originalStorage = getOriginalLocalStorage();
+
+    expect(originalStorage).toBeDefined();
+    expect(typeof originalStorage.getItem).toBe('function');
+    expect(typeof originalStorage.setItem).toBe('function');
+    expect(typeof originalStorage.removeItem).toBe('function');
+  });
+
+  it('should be able to store and get data', () => {
+    const originalStorage = getOriginalLocalStorage();
+    const testKey = '__test_key__';
+    const testValue = 'test-value';
+
+    originalStorage.removeItem(testKey);
+
+    originalStorage.setItem(testKey, testValue);
+
+    // 验证数据是否正确存储
+    expect(originalStorage.getItem(testKey)).toBe(testValue);
+    expect(originalStorage.getItem('jolibox-sdk-test:__test_key__')).toBeNull();
+
+    // 清理测试数据
+    originalStorage.removeItem(testKey);
+    expect(originalStorage.getItem(testKey)).toBeNull();
+    expect(originalStorage.getItem('jolibox-sdk-test:__test_key__')).toBeNull();
+  });
+});

package/src/loader/__tests__/localstorage-protector.ts

@@ -0,0 +1,191 @@
+type StorageIsolationOptions = {
+  namespace?: string;
+  debug?: boolean;
+};
+
+declare global {
+  interface Window {
+    __joliboxLocalStorage__: typeof window.localStorage;
+  }
+}
+
+export function createStorageIsolation(options: StorageIsolationOptions = {}) {
+  const namespace = options.namespace || getJoliMpId();
+  const debug = options.debug || true;
+  const observedFrames = new WeakSet<HTMLIFrameElement>();
+
+  function getJoliMpId() {
+    const urlParams = new URLSearchParams(window.location.search);
+    return urlParams.get('mpId') ?? urlParams.get('appId') ?? urlParams.get('gameId') ?? '';
+  }
+
+  function _log(message: string) {
+    if (debug) {
+      console.log(`[StorageIsolation] ${message}`);
+    }
+  }
+
+  function createIsolatedStorage() {
+    const originalStorage = window.localStorage;
+
+    return {
+      setItem(key: string, value: string) {
+        const namespacedKey = key.startsWith(`${namespace}:`) ? key : `${namespace}:${key}`;
+        originalStorage.setItem(namespacedKey, value);
+      },
+      getItem(key: string) {
+        const namespacedKey = key.startsWith(`${namespace}:`) ? key : `${namespace}:${key}`;
+        let value = originalStorage.getItem(namespacedKey);
+        if (value === null) {
+          // 如果命名空间不存在，则尝试直接获取原始键
+          const originalKey = key.startsWith(`${namespace}:`) ? key.slice(namespace.length + 1) : key;
+          value = originalStorage.getItem(originalKey);
+        }
+        return value;
+      },
+      removeItem(key: string) {
+        const namespacedKey = key.startsWith(`${namespace}:`) ? key : `${namespace}:${key}`;
+        originalStorage.removeItem(namespacedKey);
+      },
+      clear() {
+        const keys = Object.keys(originalStorage);
+        for (const key of keys) {
+          if (key.startsWith(`${namespace}:`)) {
+            originalStorage.removeItem(key);
+          }
+        }
+      },
+      key(index: number) {
+        const keys = Object.keys(originalStorage)
+          .filter((key) => key.startsWith(`${namespace}:`))
+          .map((key) => key.slice(namespace.length + 1));
+        return keys[index] || null;
+      },
+      get length() {
+        return Object.keys(originalStorage).filter((key) => key.startsWith(`${namespace}:`)).length;
+      }
+    };
+  }
+
+  function injectIsolatedStorage(
+    frameWindow: Window,
+    isolatedStorage: ReturnType<typeof createIsolatedStorage>
+  ) {
+    try {
+      const originalStorage = frameWindow.localStorage;
+      window.__joliboxLocalStorage__ = originalStorage;
+
+      type StorageProp = keyof typeof isolatedStorage;
+      const storageProxy = new Proxy(originalStorage, {
+        get: (target, prop: StorageProp) => {
+          if (prop in isolatedStorage) {
+            return isolatedStorage[prop];
+          }
+          if (typeof target[prop] === 'function') {
+            return target[prop].bind(target);
+          }
+          return target[prop];
+        },
+        set: (target, prop: StorageProp, value) => {
+          if (prop === 'length') {
+            return true;
+          }
+          if (prop in isolatedStorage) {
+            isolatedStorage[prop] = value;
+            return true;
+          }
+          target[prop] = value;
+          return true;
+        }
+      });
+
+      Object.defineProperty(frameWindow, 'localStorage', {
+        get: () => storageProxy,
+        configurable: true
+      });
+    } catch (e) {
+      _log(`Failed to inject storage proxy: ${e}`);
+    }
+  }
+
+  function injectIsolation(frame: HTMLIFrameElement) {
+    try {
+      const frameWindow = frame.contentWindow;
+      const frameDocument = frame.contentDocument;
+
+      if (!frameWindow || !frameDocument) {
+        _log('Cannot access frame content - likely due to same-origin policy');
+        return;
+      }
+
+      const isolatedStorage = createIsolatedStorage();
+      injectIsolatedStorage(frameWindow, isolatedStorage);
+      _log(`Successfully isolated storage for frame: ${frame.src}`);
+    } catch (e) {
+      _log(`Injection failed: ${e}`);
+    }
+  }
+
+  function isolateFrame(frame: HTMLIFrameElement) {
+    if (observedFrames.has(frame)) {
+      return;
+    }
+
+    try {
+      frame.addEventListener('load', () => {
+        injectIsolation(frame);
+      });
+      if (frame.contentDocument && frame.contentDocument.readyState === 'complete') {
+        injectIsolation(frame);
+      }
+
+      observedFrames.add(frame);
+    } catch (e) {
+      _log(`Failed to isolate frame: ${e}`);
+    }
+  }
+
+  function handleExistingFrames() {
+    document.querySelectorAll('iframe').forEach((frame) => {
+      injectIsolation(frame);
+    });
+  }
+
+  function startObserving() {
+    handleExistingFrames();
+
+    const observer = new MutationObserver((mutations) => {
+      mutations.forEach((mutation) => {
+        mutation.addedNodes.forEach((node) => {
+          if (node instanceof HTMLIFrameElement) {
+            isolateFrame(node);
+          }
+        });
+      });
+    });
+
+    observer.observe(document.documentElement, {
+      childList: true,
+      subtree: true
+    });
+
+    _log('Started observing iframe creation');
+  }
+
+  function isolateWindowStorage() {
+    const isolatedStorage = createIsolatedStorage();
+    injectIsolatedStorage(window, isolatedStorage);
+  }
+
+  // Initialize
+  startObserving();
+  isolateWindowStorage();
+
+  // Return public API if needed
+  return {
+    isolateFrame,
+    isolateWindowStorage
+  };
+}
+
+createStorageIsolation();

package/src/loader/h5.ts

@@ -5,6 +5,7 @@ import { getBoostrapModuleUrl, getImplementModuleUrl } from './index';
 import { timeline } from '../events';
 import { testMode } from '@/utils/env';
 import { trackError } from '@/utils/event-tracker';
+import { getOriginalLocalStorage } from './local-storage';
 
 const LOCAL_STORE_KEY = 'jolibox-sdk-loadermeta';
 interface LocalStoreMeta {
@@ -16,7 +17,11 @@ interface LocalStoreMeta {
   timestamp?: number;
 }
 
-const CURRENT_VERSION_STORE: LocalStoreMeta = JSON.parse(localStorage.getItem(LOCAL_STORE_KEY) ?? '{}');
+getOriginalLocalStorage();
+
+const CURRENT_VERSION_STORE: LocalStoreMeta = JSON.parse(
+  window.__joliboxLocalStorage__.getItem(LOCAL_STORE_KEY) ?? '{}'
+);
 const now = Date.now();
 
 const expired = (now: number, prev: number) =>
@@ -67,7 +72,7 @@ async function fetchCurrentRemoteScript() {
       }
     }
 
-    localStorage.setItem(LOCAL_STORE_KEY, JSON.stringify(currentStore));
+    window.__joliboxLocalStorage__.setItem(LOCAL_STORE_KEY, JSON.stringify(currentStore));
   } catch (error) {
     console.warn('Failed to fetch loader metadata: ', error);
   }

package/src/loader/local-storage.ts

@@ -0,0 +1,33 @@
+export function getOriginalLocalStorage(): Storage {
+  try {
+    if (window.__joliboxLocalStorage__) {
+      return window.__joliboxLocalStorage__;
+    }
+
+    let originalDescriptor = Object.getOwnPropertyDescriptor(window, 'localStorage');
+    if (originalDescriptor && originalDescriptor.get) {
+      const originalLocalStorage = originalDescriptor.get.call(window);
+      window.__joliboxLocalStorage__ = originalLocalStorage;
+      return originalLocalStorage;
+    }
+
+    originalDescriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(window), 'localStorage');
+    if (originalDescriptor && originalDescriptor.get) {
+      const originalLocalStorage = originalDescriptor.get.call(window);
+      return originalLocalStorage;
+    }
+
+    const windowProto = Window.prototype;
+    const protoDescriptor = Object.getOwnPropertyDescriptor(windowProto, 'localStorage');
+    if (protoDescriptor && protoDescriptor.get) {
+      const protoLocalStorage = protoDescriptor.get.call(window);
+      window.__joliboxLocalStorage__ = protoLocalStorage;
+      return protoLocalStorage;
+    }
+
+    return localStorage;
+  } catch (e) {
+    console.warn('Failed to get original localStorage, fallback to default implementation', e);
+    return localStorage;
+  }
+}

package/src/sdks/lifecycle.ts

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

package/src/sdks/router.ts

@@ -0,0 +1,30 @@
+import { BaseSDK } from './sdk';
+import { Router, ResponseType, StandardResponse } from '@jolibox/types';
+
+export class RouterSDK extends BaseSDK implements Router {
+  async openSchema(schema: string) {
+    const errMsg = this.canIUseIfThrow('router.openSchema');
+    if (errMsg) {
+      return errMsg;
+    }
+    return await this.commands.executeCommand('RouterSDK.openSchema', schema);
+  }
+  async openPage(url: string): Promise<
+    StandardResponse<{
+      webviewId: number;
+    }>
+  > {
+    const errMsg = this.canIUseIfThrow('router.openPage');
+    if (errMsg) {
+      return errMsg;
+    }
+    return await this.commands.executeCommand('RouterSDK.openPage', url);
+  }
+  async closePage(webviewId: number) {
+    const errMsg = this.canIUseIfThrow('router.closePage');
+    if (errMsg) {
+      return errMsg;
+    }
+    return await this.commands.executeCommand('RouterSDK.closePage', webviewId);
+  }
+}