@series-inc/venus-sdk 3.2.0 → 3.2.1-beta.0

package/dist/index.cjs

@@ -2647,21 +2647,23 @@ function initializeRoomsApi(venusApi, host) {
 }
 
 // src/storage/MockStorageApi.ts
+var STORAGE_PREFIXES = {
+  globalStorage: "venus:global",
+  deviceCache: "venus:deviceCache",
+  appStorage: "venus:appStorage"
+};
 function createMockStorageApi(storageType, appUrl) {
   const appIdentifier = appUrl ? generateAppIdentifier(appUrl) : null;
-  let prefix;
+  let prefix = STORAGE_PREFIXES[storageType];
   let syncDelay = 0;
   switch (storageType) {
     case "deviceCache":
-      prefix = "venus:app";
       syncDelay = 0;
       break;
     case "appStorage":
-      prefix = "venus:app";
       syncDelay = 100;
       break;
     case "globalStorage":
-      prefix = "venus:global";
       syncDelay = 100;
       break;
     default:
@@ -2674,29 +2676,38 @@ var MockStorageApi = class {
   constructor(prefix, syncDelay) {
     __publicField(this, "prefix");
     __publicField(this, "syncDelay");
+    __publicField(this, "orderStorageKey");
     this.prefix = prefix;
     this.syncDelay = syncDelay;
+    this.orderStorageKey = `${prefix}__order__`;
   }
   async clear() {
+    const keysToRemove = [];
     const fullLength = localStorage.length;
     for (let i = 0; i < fullLength; i++) {
       const fullKey = localStorage.key(i);
-      if (fullKey && fullKey.startsWith(this.prefix)) {
-        localStorage.removeItem(fullKey);
+      if (!fullKey || fullKey === this.orderStorageKey) {
+        continue;
       }
+      if (fullKey.startsWith(this.prefix)) {
+        keysToRemove.push(fullKey);
+      }
+    }
+    for (const key of keysToRemove) {
+      localStorage.removeItem(key);
     }
+    this.clearOrder();
     await this.simulateSyncDelay();
   }
   async getAllItems() {
     const items = new Array();
-    const fullLength = localStorage.length;
-    for (let i = 0; i < fullLength; i++) {
-      const fullKey = localStorage.key(i);
-      if (fullKey && fullKey.startsWith(this.prefix)) {
-        const item = localStorage.getItem(fullKey);
-        if (item) {
-          items.push(item);
-        }
+    const orderedKeys = this.keys();
+    for (const key of orderedKeys) {
+      const value = localStorage.getItem(this.buildKey(key));
+      if (value !== null) {
+        items.push(value);
+      } else {
+        this.removeFromOrder(key);
       }
     }
     return items;
@@ -2721,11 +2732,13 @@ var MockStorageApi = class {
     const fullKey = this.buildKey(key);
     await this.simulateSyncDelay();
     localStorage.removeItem(fullKey);
+    this.removeFromOrder(key);
   }
   async setItem(key, item) {
     const fullKey = this.buildKey(key);
     await this.simulateSyncDelay();
     localStorage.setItem(fullKey, item);
+    this.upsertOrder(key);
   }
   async setMultipleItems(entries) {
     for (const entry of entries) {
@@ -2733,6 +2746,7 @@ var MockStorageApi = class {
       localStorage.setItem(fullKey, entry.value);
     }
     await this.simulateSyncDelay();
+    this.bulkUpsertOrder(entries.map((entry) => entry.key));
   }
   async removeMultipleItems(keys) {
     for (const key of keys) {
@@ -2740,6 +2754,7 @@ var MockStorageApi = class {
       localStorage.removeItem(fullKey);
     }
     await this.simulateSyncDelay();
+    this.bulkRemoveFromOrder(keys);
   }
   buildKey(key) {
     const prefix = this.prefix;
@@ -2750,17 +2765,8 @@ var MockStorageApi = class {
     return fullKey.substring(prefix.length);
   }
   keys() {
-    const keys = new Array();
-    let length = localStorage.length;
-    for (let i = 0; i < length; i++) {
-      const fullKey = localStorage.key(i);
-      if (fullKey && fullKey.startsWith(this.prefix)) {
-        length++;
-        const key = this.extractKey(fullKey);
-        keys.push(key);
-      }
-    }
-    return keys;
+    const order = this.readOrder();
+    return [...order];
   }
   async simulateSyncDelay() {
     const syncDelay = this.syncDelay;
@@ -2768,6 +2774,127 @@ var MockStorageApi = class {
       await new Promise((resolve) => setTimeout(resolve, syncDelay));
     }
   }
+  readOrder() {
+    const raw = localStorage.getItem(this.orderStorageKey);
+    if (!raw) {
+      return this.rebuildOrderFromStorage();
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) {
+        return this.normalizeOrder(parsed);
+      }
+    } catch {
+    }
+    return this.rebuildOrderFromStorage();
+  }
+  normalizeOrder(order) {
+    const seen = /* @__PURE__ */ new Set();
+    const normalized = [];
+    let changed = false;
+    for (const entry of order) {
+      if (typeof entry !== "string") {
+        changed = true;
+        continue;
+      }
+      if (seen.has(entry)) {
+        changed = true;
+        continue;
+      }
+      const fullKey = this.buildKey(entry);
+      if (localStorage.getItem(fullKey) === null) {
+        changed = true;
+        continue;
+      }
+      seen.add(entry);
+      normalized.push(entry);
+    }
+    if (changed) {
+      this.writeOrder(normalized);
+    }
+    return normalized;
+  }
+  rebuildOrderFromStorage() {
+    const keys = [];
+    const total = localStorage.length;
+    for (let i = 0; i < total; i++) {
+      const fullKey = localStorage.key(i);
+      if (!fullKey) continue;
+      if (fullKey === this.orderStorageKey) continue;
+      if (fullKey.startsWith(this.prefix)) {
+        keys.push(this.extractKey(fullKey));
+      }
+    }
+    this.writeOrder(keys);
+    return keys;
+  }
+  upsertOrder(key) {
+    const order = this.readOrder();
+    const index = order.indexOf(key);
+    if (index !== -1) {
+      order.splice(index, 1);
+    }
+    order.push(key);
+    this.writeOrder(order);
+  }
+  bulkUpsertOrder(keys) {
+    const dedupedKeys = this.dedupeKeys(keys);
+    if (dedupedKeys.length === 0) {
+      return;
+    }
+    const order = this.readOrder();
+    const keysSet = new Set(dedupedKeys);
+    const filtered = order.filter((entry) => !keysSet.has(entry));
+    for (const key of dedupedKeys) {
+      filtered.push(key);
+    }
+    this.writeOrder(filtered);
+  }
+  removeFromOrder(key) {
+    const order = this.readOrder();
+    const index = order.indexOf(key);
+    if (index !== -1) {
+      order.splice(index, 1);
+      this.writeOrder(order);
+    }
+  }
+  bulkRemoveFromOrder(keys) {
+    const dedupedKeys = this.dedupeKeys(keys);
+    if (dedupedKeys.length === 0) {
+      return;
+    }
+    const order = this.readOrder();
+    const keysSet = new Set(dedupedKeys);
+    const filtered = order.filter((entry) => !keysSet.has(entry));
+    if (filtered.length !== order.length) {
+      this.writeOrder(filtered);
+    }
+  }
+  writeOrder(order) {
+    if (order.length === 0) {
+      localStorage.removeItem(this.orderStorageKey);
+      return;
+    }
+    localStorage.setItem(this.orderStorageKey, JSON.stringify(order));
+  }
+  clearOrder() {
+    localStorage.removeItem(this.orderStorageKey);
+  }
+  dedupeKeys(keys) {
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const key of keys) {
+      if (typeof key !== "string") {
+        continue;
+      }
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      result.push(key);
+    }
+    return result;
+  }
 };
 function generateAppIdentifier(appUrl) {
   if (!appUrl) appUrl = "";
@@ -3438,7 +3565,72 @@ function initializeTime(venusApi, host) {
 }
 
 // src/version.ts
-var SDK_VERSION = "3.2.0";
+var SDK_VERSION = "3.2.1-beta.0";
+
+// src/shared-assets/base64Utils.ts
+function base64ToArrayBuffer(base64) {
+  const binaryString = atob(base64);
+  const len = binaryString.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+function base64ToUtf8(base64) {
+  if (typeof TextDecoder !== "undefined") {
+    const decoder = new TextDecoder("utf-8");
+    const buffer = base64ToArrayBuffer(base64);
+    return decoder.decode(new Uint8Array(buffer));
+  }
+  if (typeof globalThis !== "undefined" && typeof globalThis.Buffer !== "undefined") {
+    const BufferCtor = globalThis.Buffer;
+    return BufferCtor.from(base64, "base64").toString("utf-8");
+  }
+  const binaryString = atob(base64);
+  let result = "";
+  for (let i = 0; i < binaryString.length; i++) {
+    result += String.fromCharCode(binaryString.charCodeAt(i));
+  }
+  return decodeURIComponent(escape(result));
+}
+
+// src/shared-assets/RpcSharedAssetsApi.ts
+var RpcSharedAssetsApi = class {
+  constructor(rpcClient, venusApi) {
+    __publicField(this, "venusApi");
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+    this.venusApi = venusApi;
+  }
+  async loadAssetsBundle(game, bundleKey, fileType = "stow") {
+    try {
+      const response = await this.rpcClient.callT("H5_LOAD_EMBEDDED_ASSET" /* H5_LOAD_EMBEDDED_ASSET */, {
+        assetKey: bundleKey
+      });
+      return base64ToArrayBuffer(response.base64Data);
+    } catch (err) {
+      try {
+        const blob = await this.venusApi.cdn.fetchBlob(`${game}/${bundleKey}.${fileType}`);
+        return await blob.arrayBuffer();
+      } catch (e) {
+        throw new Error(`Failed to load ${bundleKey}`);
+      }
+    }
+  }
+};
+
+// src/shared-assets/MockSharedAssetsApi.ts
+var MockSharedAssetsApi = class {
+  constructor(venusApi) {
+    __publicField(this, "venusApi");
+    this.venusApi = venusApi;
+  }
+  async loadAssetsBundle(game, bundleKey, fileType = "stow") {
+    const blob = await this.venusApi.cdn.fetchBlob(`${game}/${bundleKey}.${fileType}`);
+    return await blob.arrayBuffer();
+  }
+};
 
 // src/shared-assets/embeddedLibrariesManifest.ts
 var DEFAULT_SHARED_LIB_CDN_BASE = "https://venus-static-01293ak.web.app/libs";
@@ -3581,103 +3773,6 @@ function getLibraryDefinition(libraryKey) {
   return definition;
 }
 
-// src/shared-assets/base64Utils.ts
-function base64ToArrayBuffer(base64) {
-  const binaryString = atob(base64);
-  const len = binaryString.length;
-  const bytes = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    bytes[i] = binaryString.charCodeAt(i);
-  }
-  return bytes.buffer;
-}
-function base64ToUtf8(base64) {
-  if (typeof TextDecoder !== "undefined") {
-    const decoder = new TextDecoder("utf-8");
-    const buffer = base64ToArrayBuffer(base64);
-    return decoder.decode(new Uint8Array(buffer));
-  }
-  if (typeof globalThis !== "undefined" && typeof globalThis.Buffer !== "undefined") {
-    const BufferCtor = globalThis.Buffer;
-    return BufferCtor.from(base64, "base64").toString("utf-8");
-  }
-  const binaryString = atob(base64);
-  let result = "";
-  for (let i = 0; i < binaryString.length; i++) {
-    result += String.fromCharCode(binaryString.charCodeAt(i));
-  }
-  return decodeURIComponent(escape(result));
-}
-
-// src/shared-assets/RpcSharedAssetsApi.ts
-var RpcSharedAssetsApi = class {
-  constructor(rpcClient, venusApi) {
-    __publicField(this, "venusApi");
-    __publicField(this, "rpcClient");
-    this.rpcClient = rpcClient;
-    this.venusApi = venusApi;
-  }
-  async loadAssetsBundle(game, bundleKey, fileType = "stow") {
-    try {
-      const response = await this.rpcClient.callT("H5_LOAD_EMBEDDED_ASSET" /* H5_LOAD_EMBEDDED_ASSET */, {
-        assetKey: bundleKey
-      });
-      return base64ToArrayBuffer(response.base64Data);
-    } catch (err) {
-      try {
-        const blob = await this.venusApi.cdn.fetchBlob(`${game}/${bundleKey}.${fileType}`);
-        return await blob.arrayBuffer();
-      } catch (e) {
-        throw new Error(`Failed to load ${bundleKey}`);
-      }
-    }
-  }
-  async loadLibraryCode(libraryKey) {
-    const definition = getLibraryDefinition(libraryKey);
-    try {
-      const response = await this.rpcClient.callT("H5_LOAD_EMBEDDED_ASSET" /* H5_LOAD_EMBEDDED_ASSET */, {
-        assetKey: definition.assetKey
-      });
-      return base64ToUtf8(response.base64Data);
-    } catch (err) {
-      console.error(
-        `[Venus Libraries] Failed to load ${libraryKey} from host via RPC:`,
-        err
-      );
-      console.warn(
-        `[Venus Libraries] Falling back to CDN for ${libraryKey}. This may indicate an asset packaging issue.`
-      );
-      try {
-        const cdnUrl = this.venusApi.cdn.resolveSharedLibUrl(definition.cdnPath);
-        const response = await this.venusApi.cdn.fetchFromCdn(cdnUrl);
-        return await response.text();
-      } catch (cdnError) {
-        throw new Error(
-          `Failed to load embedded library ${libraryKey}: RPC failed, CDN fallback failed: ${cdnError.message}`
-        );
-      }
-    }
-  }
-};
-
-// src/shared-assets/MockSharedAssetsApi.ts
-var MockSharedAssetsApi = class {
-  constructor(venusApi) {
-    __publicField(this, "venusApi");
-    this.venusApi = venusApi;
-  }
-  async loadAssetsBundle(game, bundleKey, fileType = "stow") {
-    const blob = await this.venusApi.cdn.fetchBlob(`${game}/${bundleKey}.${fileType}`);
-    return await blob.arrayBuffer();
-  }
-  async loadLibraryCode(libraryKey) {
-    const definition = getLibraryDefinition(libraryKey);
-    const url = this.venusApi.cdn.resolveSharedLibUrl(definition.cdnPath);
-    const response = await this.venusApi.cdn.fetchFromCdn(url);
-    return await response.text();
-  }
-};
-
 // src/leaderboard/utils.ts
 var HASH_ALGORITHM_WEB_CRYPTO = "SHA-256";
 var HASH_ALGORITHM_NODE = "sha256";
@@ -5113,7 +5208,7 @@ var RemoteHost = class {
       5e3
     );
     transport.instanceId = response.instanceId;
-    this.log(`Remote Host Initialized with id: ${transport.instanceId}`);
+    this.log(`Remote Host Initialized with id: ${transport.instanceId}, response: ${JSON.stringify(response)}`);
     const profile = response.profile;
     const sanitizedProfile = {
       id: profile.id,