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

package/dist/venus-api/index.cjs

@@ -101,21 +101,23 @@ var init_core = __esm({
 });
 
 // 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:
@@ -128,29 +130,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;
@@ -175,11 +186,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) {
@@ -187,6 +200,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) {
@@ -194,6 +208,7 @@ var MockStorageApi = class {
       localStorage.removeItem(fullKey);
     }
     await this.simulateSyncDelay();
+    this.bulkRemoveFromOrder(keys);
   }
   buildKey(key) {
     const prefix = this.prefix;
@@ -204,17 +219,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;
@@ -222,6 +228,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 = "";
@@ -415,40 +542,6 @@ var RpcPopupsApi = class {
     __publicField(this, "rpcClient");
     this.rpcClient = rpcClient;
   }
-  async showActionSheet(items, options) {
-    const result = await this.rpcClient.call(
-      "H5_ACTION_SHEET_SHOW" /* ACTION_SHEET_SHOW */,
-      {
-        title: options?.title || "",
-        message: options?.message || "",
-        options: items,
-        cancelButtonText: options?.cancelButtonText || "Cancel"
-      }
-    );
-    return result;
-  }
-  async showAlert(title, message, options) {
-    const buttonText = options?.buttonText || "OK";
-    await this.rpcClient.call("H5_ALERT_DIALOG" /* ALERT_DIALOG */, {
-      title,
-      message,
-      buttonText
-    });
-  }
-  async showConfirm(title, message, options) {
-    const confirmText = options?.confirmText || "OK";
-    const cancelText = options?.cancelText || "Cancel";
-    const result = await this.rpcClient.call(
-      "H5_CONFIRM_DIALOG" /* CONFIRM_DIALOG */,
-      {
-        title,
-        message,
-        confirmText,
-        cancelText
-      }
-    );
-    return result;
-  }
   async showToast(message, options) {
     const duration = options?.duration ?? 3e3;
     const variant = options?.variant ?? "info";
@@ -472,21 +565,6 @@ var MockPopupsApi = class {
     __publicField(this, "overlay");
     this.overlay = override;
   }
-  showActionSheet(items, options) {
-    console.log(
-      `[Venus Mock] Show Action sheet, items: ${JSON.stringify(items, null, 2)}, options: ${JSON.stringify(options, null, 2)}`
-    );
-    return this.overlay.showActionSheet(items, options);
-  }
-  async showAlert(title, message, options) {
-    window.alert(`${title}
-${message}`);
-  }
-  async showConfirm(title, message, options) {
-    const result = window.confirm(`${title || "Confirm"}
-${message}`);
-    return result;
-  }
   async showToast(message, options) {
     const variant = options?.variant ?? "info";
     const duration = options?.duration ?? 3e3;
@@ -513,41 +591,6 @@ ${message}`);
 
 // src/popups/index.ts
 function initializePopups(venusApi, host) {
-  venusApi.showToast = async (input) => {
-    if (typeof input === "string") {
-      return await host.popups.showToast(input);
-    } else {
-      return await host.popups.showToast(input.message, {
-        duration: input.duration,
-        action: input.action,
-        variant: "success"
-      });
-    }
-  };
-  venusApi.showAlert = async (input) => {
-    await host.popups.showAlert(input.title, input.message, {
-      buttonText: input.buttonText
-    });
-  };
-  venusApi.showConfirm = async (input) => {
-    const confirmed = await host.popups.showConfirm(
-      input.title,
-      input.message,
-      {
-        confirmText: input.confirmText,
-        cancelText: input.cancelText
-      }
-    );
-    return confirmed;
-  };
-  venusApi.showActionSheet = async (input) => {
-    return await host.popups.showActionSheet(input.options, {
-      title: input.title,
-      message: input.message,
-      cancelButtonText: input.cancelButtonText,
-      disableCancel: input.disableCancel
-    });
-  };
   venusApi.popups = host.popups;
 }
 
@@ -4261,7 +4304,7 @@ var MockCdnApi = class {
     const cleanSubPath = subPath.startsWith("/") ? subPath.slice(1) : subPath;
     const isLocalhost = typeof window !== "undefined" && (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1");
     if (isLocalhost && !this.forceRemoteCdn) {
-      return `/${cleanSubPath}`;
+      return `cdn/${cleanSubPath}`;
     }
     const pathParts = cleanSubPath.split("/");
     const encodedParts = pathParts.map((part, index) => {
@@ -5069,6 +5112,54 @@ function initializeLoggingApi(venusApi, host) {
   };
 }
 
+// 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;
+}
+
+// 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 EMBEDDED_LIBRARIES = [
   {
@@ -5183,7 +5274,7 @@ var EMBEDDED_LIBRARIES = [
     // Not ready yet - WASM loading needs additional work
   }
 ];
-var EMBEDDED_LIBRARY_BY_KEY = EMBEDDED_LIBRARIES.reduce(
+EMBEDDED_LIBRARIES.reduce(
   (acc, lib) => {
     acc[lib.libraryKey] = lib;
     return acc;
@@ -5198,113 +5289,6 @@ EMBEDDED_LIBRARIES.filter(
     libraryKey: lib.libraryKey
   }))
 );
-function getLibraryDefinition(libraryKey) {
-  const definition = EMBEDDED_LIBRARY_BY_KEY[libraryKey];
-  if (!definition) {
-    const availableKeys = Object.keys(EMBEDDED_LIBRARY_BY_KEY).join(", ");
-    throw new Error(
-      `Unsupported embedded library: ${libraryKey}. Available libraries: ${availableKeys}`
-    );
-  }
-  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/game-preloader/MockPreloaderApi.ts
 var MockPreloaderApi = class {
@@ -6870,7 +6854,7 @@ function createHost(venusApi, isMock) {
 }
 
 // src/version.ts
-var SDK_VERSION = "3.2.0";
+var SDK_VERSION = "3.2.1-beta.1";
 
 // src/social/index.ts
 function initializeSocial(venusApi, host) {