@goplus123/core-api 1.0.1 → 1.0.3

package/README.md

@@ -239,7 +239,65 @@ apiError.use((error, ctx, next) => {
 
 ### fetchGuid()
 
-- 作用：生成一个短 id（playground 用于 WS `protocols`）
+- 作用：生成/读取一个稳定的设备唯一标识（unikey），用于跨请求/跨连接的设备识别
+- 行为：
+  - 读取存储：优先从当前 `KeyValueStorage` 读取 `uKey`
+  - 解析兼容：支持三种历史值格式（UUID / 32 位 hex / base64(bytes)）
+  - 缓存写入：若不存在或不可解析，会生成新的 UUID 并写回存储
+  - 默认输出：返回 UUID（带 `-`），例如 `xxxxxxxx-xxxx-4xxx-8xxx-xxxxxxxxxxxx`
+- 默认存储策略（见 [`utils/uniqueKey.ts`](file:///d:/working/GX/tsup/packages/api/src/utils/uniqueKey.ts)）：
+  - Web 环境：使用 `localStorage`
+  - 非 Web 或 `localStorage` 不可用：使用进程内 memory storage 兜底（保证同进程稳定）
+
+### createFetchGuid(storage, options?)
+
+- 作用：基于指定的 `KeyValueStorage` 创建一个 `fetchGuid()` 函数（推荐方式，便于按平台定制）
+- options：
+  - `key?: string`：存储 key，默认 `uKey`
+  - `format?: 'uuid' | 'hex' | 'base64'`：返回格式，默认 `'uuid'`
+  - `prefix?: string`：输出前缀（用于区分来源端，例如 `'pc_' / 'h5_'`），默认 `''`
+
+示例：
+
+```ts
+import { createFetchGuid, webStorage } from '@goplus123/core-api'
+
+export const fetchGuidPc = createFetchGuid(webStorage, { format: 'uuid', prefix: 'pc_' })
+export const fetchGuidH5 = createFetchGuid(webStorage, { format: 'hex', prefix: 'h5_' })
+```
+
+### setUniqueKeyStorage(adapter)
+
+- 作用：设置 `fetchGuid()` 的全局存储适配器（用于 App/小程序等非 Web 环境注入 native storage）
+- 建议：尽量在 `initSDK()` 之前调用，避免同一进程内出现“先生成、后换存储”的多份 id
+
+示例（伪代码）：
+
+```ts
+import type { KeyValueStorage } from '@goplus123/core-api'
+import { setUniqueKeyStorage } from '@goplus123/core-api'
+
+const appStorage: KeyValueStorage = {
+  get(key) {
+    return NativeStorage.get(key)
+  },
+  set(key, val) {
+    NativeStorage.set(key, val)
+  },
+}
+
+setUniqueKeyStorage(appStorage)
+```
+
+### webStorage
+
+- 作用：浏览器端 `KeyValueStorage` 适配器，基于 `window.localStorage`
+- 兼容：SSR/Node 下安全返回 `null`；浏览器隐私模式/禁用存储时会吞掉异常（不抛错）
+
+### KeyValueStorage
+
+- 作用：unikey 存储抽象（只要求 `get/set` 两个方法）
+- 定义：[`utils/storage.ts`](file:///d:/working/GX/tsup/packages/api/src/utils/storage.ts)
 
 ---
 

package/dist/index.cjs

@@ -22,6 +22,7 @@ var index_exports = {};
 __export(index_exports, {
   apiError: () => apiError,
   callApi: () => requestApi,
+  createFetchGuid: () => createFetchGuid,
   destroySDK: () => destroySDK,
   fetchGuid: () => fetchGuid,
   getSDK: () => getSDK,
@@ -29,7 +30,9 @@ __export(index_exports, {
   initSDK: () => initSDK,
   notify: () => notify,
   requestApi: () => requestApi,
-  requestApiSpec: () => requestApi
+  requestApiSpec: () => requestApi,
+  setUniqueKeyStorage: () => setUniqueKeyStorage,
+  webStorage: () => webStorage
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -429,7 +432,7 @@ var WsClient = class {
         ...options.reconnect
       },
       heartbeat: {
-        interval: 1e4,
+        interval: 3e4,
         timeout: 3e4,
         pingType: "ping",
         pongType: "pong",
@@ -715,6 +718,10 @@ var WsClient = class {
           this.lastPongTime = Date.now();
           return;
         }
+        if (this.isAliveAck(msg, payload)) {
+          this.lastPongTime = Date.now();
+          return;
+        }
         const requestId = msg.requestId ?? (payload && typeof payload === "object" ? payload.requestId ?? payload?.data?.requestId : void 0);
         const resolved = requestId ? this.tryResolvePending(requestId, type, payload) : false;
         if (!resolved) {
@@ -730,6 +737,10 @@ var WsClient = class {
           this.lastPongTime = Date.now();
           return;
         }
+        if (this.isAliveAck(msg, payload)) {
+          this.lastPongTime = Date.now();
+          return;
+        }
         const requestId = msg.requestId ?? (payload && typeof payload === "object" ? payload.requestId ?? payload?.data?.requestId : void 0);
         const resolved = requestId ? this.tryResolvePending(requestId, functionName, payload) : false;
         if (!resolved) {
@@ -779,7 +790,23 @@ var WsClient = class {
     const ping = () => {
       if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
       this.lastPingTime = Date.now();
-      this.send(hb.pingType ?? "ping");
+      const requestId = this.requestId;
+      const deviceType = this.headerConfig.deviceType === "" || this.headerConfig.deviceType === void 0 ? 1 : this.headerConfig.deviceType;
+      const message = JSON.stringify({
+        service: "connection",
+        functionName: "isAlive",
+        data: {
+          _heartBeat: true,
+          deviceType,
+          deviceId: this.headerConfig.deviceId ?? "",
+          platformId: this.headerConfig.platformId ?? "",
+          version: this.headerConfig.version ?? "",
+          uuid: this.options.protocols,
+          requestId,
+          childPlatformId: this.headerConfig.childPlatformId ?? ""
+        }
+      });
+      this.ws.send(message);
     };
     ping();
     this.heartbeatTimer = window.setInterval(() => {
@@ -898,6 +925,12 @@ var WsClient = class {
   isPong(type) {
     return type === (this.options.heartbeat?.pongType ?? "pong");
   }
+  isAliveAck(msg, payload) {
+    if (!msg || typeof msg !== "object") return false;
+    if (msg.service !== "connection") return false;
+    if (msg.functionName !== "isAlive" && msg.type !== "isAlive") return false;
+    return payload && typeof payload === "object" && payload.status === 200;
+  }
   async buildURL(params) {
     let urlStr = this.options.url;
     if (!/^\w+:\/\//.test(urlStr)) {
@@ -4278,11 +4311,286 @@ var cmsEndpoints = {
   })
 };
 
+// src/spec/auth.ts
+var authEndpoints = {
+  playerRegisterRequestCode: defineEndpoint({
+    id: "auth.playerRegisterRequestCode",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "playerRegisterRequestCode",
+      requestSchema: PlayerRegisterRequestCodeReqSchema
+    }
+  }),
+  playerRegisterWithCode: defineEndpoint({
+    id: "auth.playerRegisterWithCode",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "playerRegisterWithCode",
+      requestSchema: PlayerRegisterWithCodeReqSchema
+    }
+  }),
+  playerLoginWithSessionToken: defineEndpoint({
+    id: "auth.playerLoginWithSessionToken",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "playerLoginWithSessionToken",
+      requestSchema: PlayerLoginWithSessionTokenReqSchema
+    }
+  }),
+  phoneNumberLoginWithPassword: defineEndpoint({
+    id: "auth.phoneNumberLoginWithPassword",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "phoneNumberLoginWithPassword",
+      requestSchema: PhoneNumberLoginWithPasswordReqSchema
+    }
+  }),
+  playerLoginOrRegisterWithSMS: defineEndpoint({
+    id: "auth.playerLoginOrRegisterWithSMS",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "playerLoginOrRegisterWithSMS",
+      requestSchema: PlayerLoginOrRegisterWithSMSReqSchema
+    }
+  }),
+  playerLogout: defineEndpoint({
+    id: "auth.playerLogout",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "playerLogout",
+      requestSchema: PlayerLogoutReqSchema
+    }
+  }),
+  authenticate: defineEndpoint({
+    id: "auth.authenticate",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "authenticate",
+      requestSchema: AuthenticateReqSchema
+    }
+  }),
+  sendSmsCode: defineEndpoint({
+    id: "auth.sendSmsCode",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "sendSmsCode",
+      requestSchema: SendSmsCodeReqSchema
+    }
+  }),
+  sendSmsCodeViber: defineEndpoint({
+    id: "auth.sendSmsCodeViber",
+    transport: "grpc",
+    grpc: {
+      service: FrontendAuthService,
+      methodName: "sendSmsCodeViber",
+      requestSchema: SendSmsCodeViberReqSchema
+    }
+  }),
+  playerLoginOrRegisterWithFacebook: defineEndpoint({
+    id: "auth.playerLoginOrRegisterWithFacebook",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFacebookService,
+      methodName: "playerLoginOrRegisterWithFacebook",
+      requestSchema: PlayerLoginOrRegisterWithFacebookReqSchema
+    }
+  }),
+  getFacebookConsentPage: defineEndpoint({
+    id: "auth.getFacebookConsentPage",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFacebookService,
+      methodName: "getFacebookConsentPage",
+      requestSchema: GetFacebookConsentPageReqSchema
+    }
+  }),
+  facebookAuthorization: defineEndpoint({
+    id: "auth.facebookAuthorization",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFacebookService,
+      methodName: "facebookAuthorization",
+      requestSchema: FacebookAuthorizationReqSchema
+    }
+  }),
+  getFacebookFriendList: defineEndpoint({
+    id: "auth.getFacebookFriendList",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFacebookService,
+      methodName: "getFacebookFriendList",
+      requestSchema: GetFacebookFriendListReqSchema
+    }
+  }),
+  manualFetchFacebookFriends: defineEndpoint({
+    id: "auth.manualFetchFacebookFriends",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFacebookService,
+      methodName: "manualFetchFacebookFriends",
+      requestSchema: ManualFetchFacebookFriendsReqSchema
+    }
+  }),
+  bindFacebookAccount: defineEndpoint({
+    id: "auth.bindFacebookAccount",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFacebookService,
+      methodName: "bindFacebookAccount",
+      requestSchema: BindFacebookAccountReqSchema
+    }
+  }),
+  unbindFacebookAccount: defineEndpoint({
+    id: "auth.unbindFacebookAccount",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFacebookService,
+      methodName: "unbindFacebookAccount",
+      requestSchema: EmptySchema
+    }
+  }),
+  facebookVerifyPhoneNumber: defineEndpoint({
+    id: "auth.facebookVerifyPhoneNumber",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFacebookService,
+      methodName: "facebookVerifyPhoneNumber",
+      requestSchema: FacebookVerifyPhoneNumberReqSchema
+    }
+  }),
+  enableFaceId: defineEndpoint({
+    id: "auth.enableFaceId",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFaceIdService,
+      methodName: "enableFaceId",
+      requestSchema: EnableFaceIdReqSchema
+    }
+  }),
+  initFaceIdSession: defineEndpoint({
+    id: "auth.initFaceIdSession",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFaceIdService,
+      methodName: "initFaceIdSession",
+      requestSchema: InitFaceIdSessionReqSchema
+    }
+  }),
+  playerLoginWithFaceId: defineEndpoint({
+    id: "auth.playerLoginWithFaceId",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFaceIdService,
+      methodName: "playerLoginWithFaceId",
+      requestSchema: PlayerLoginWithFaceIdReqSchema
+    }
+  }),
+  disableFaceId: defineEndpoint({
+    id: "auth.disableFaceId",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFaceIdService,
+      methodName: "disableFaceId",
+      requestSchema: DisableFaceIdReqSchema
+    }
+  }),
+  initEnrollSession: defineEndpoint({
+    id: "auth.initEnrollSession",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFaceIdService,
+      methodName: "initEnrollSession",
+      requestSchema: InitEnrollSessionReqSchema
+    }
+  }),
+  getFaceIdInfo: defineEndpoint({
+    id: "auth.getFaceIdInfo",
+    transport: "grpc",
+    grpc: {
+      service: FrontendFaceIdService,
+      methodName: "getFaceIdInfo",
+      requestSchema: GetFaceIdInfoReqSchema
+    }
+  }),
+  verifyPassword: defineEndpoint({
+    id: "auth.verifyPassword",
+    transport: "grpc",
+    grpc: {
+      service: FrontendPlayerService,
+      methodName: "verifyPassword",
+      requestSchema: VerifyPasswordReqSchema
+    }
+  }),
+  gLifeAuth: defineEndpoint({
+    id: "auth.gLifeAuth",
+    transport: "grpc",
+    grpc: {
+      service: GLifeService,
+      methodName: "gLifeAuth",
+      requestSchema: GLifeAuthReqSchema
+    }
+  }),
+  playerLoginWithGLife: defineEndpoint({
+    id: "auth.playerLoginWithGLife",
+    transport: "grpc",
+    grpc: {
+      service: GLifeService,
+      methodName: "playerLoginWithGLife",
+      requestSchema: PlayerLoginWithGLifeReqSchema
+    }
+  }),
+  playerLoginOrRegisterWithGLife: defineEndpoint({
+    id: "auth.playerLoginOrRegisterWithGLife",
+    transport: "grpc",
+    grpc: {
+      service: GLifeService,
+      methodName: "playerLoginOrRegisterWithGLife",
+      requestSchema: PlayerLoginOrRegisterWithGLifeReqSchema
+    }
+  }),
+  mayaAuth: defineEndpoint({
+    id: "auth.mayaAuth",
+    transport: "grpc",
+    grpc: {
+      service: MayaService,
+      methodName: "mayaAuth",
+      requestSchema: MayaAuthReqSchema
+    }
+  }),
+  playerLoginWithMaya: defineEndpoint({
+    id: "auth.playerLoginWithMaya",
+    transport: "grpc",
+    grpc: {
+      service: MayaService,
+      methodName: "playerLoginWithMaya",
+      requestSchema: PlayerLoginWithMayaReqSchema
+    }
+  }),
+  playerLoginOrRegisterWithMaya: defineEndpoint({
+    id: "auth.playerLoginOrRegisterWithMaya",
+    transport: "grpc",
+    grpc: {
+      service: MayaService,
+      methodName: "playerLoginOrRegisterWithMaya",
+      requestSchema: PlayerLoginOrRegisterWithMayaReqSchema
+    }
+  })
+};
+
 // src/spec/index.ts
 var apiMap = {
   platform: platformEndpoints,
   admin: adminEndpoints,
-  cms: cmsEndpoints
+  cms: cmsEndpoints,
+  auth: authEndpoints
 };
 
 // src/routing/router.ts
@@ -4455,54 +4763,207 @@ function pickEndpoint(variants, transport, specDefaultTransport, service, functi
   return fallback;
 }
 
-// src/utils/uniqueKey.ts
-var fetchGuid = () => {
-  let guid = getLocalItem("uKey");
-  console.log("fetchGuid", JSON.stringify(guid));
-  if (!guid) {
-    guid = generateGuid();
-    setLocalItem("uKey", maskingGuid(true, guid));
-  } else {
-    guid = maskingGuid(false, null);
+// src/utils/adapters/web.ts
+var webStorage = {
+  get(key) {
+    if (typeof window === "undefined") return null;
+    try {
+      const storage = window.localStorage;
+      if (!storage) return null;
+      return storage.getItem(key);
+    } catch {
+      return null;
+    }
+  },
+  set(key, value) {
+    if (typeof window === "undefined") return;
+    try {
+      const storage = window.localStorage;
+      if (!storage) return;
+      storage.setItem(key, value);
+    } catch {
+      return;
+    }
   }
-  return guid;
-};
-var generateGuid = () => {
-  return "10000000-1000-4000-8000-100000000000".replace(
-    /[018]/g,
-    (c) => (+c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16)
-  );
 };
-var maskingGuid = (isMask, oriUKey) => {
-  let _uKey2;
-  let uKey = oriUKey || getLocalItem("uKey");
-  if (isMask) {
-    let _uKey;
-    uKey = ((_uKey = uKey) == null ? void 0 : _uKey.replace(/-/g, "")) || "";
-    const _buffer = new Uint8Array(uKey.length / 2);
-    for (let i = 0; i < uKey.length; i += 2) {
-      _buffer[i / 2] = parseInt(uKey.substr(i, 2), 16);
-    }
-    return btoa(String.fromCharCode.apply(null, Array.from(_buffer)));
+
+// src/utils/fetchGuid.ts
+var defaultKey = "uKey";
+var guidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var hex32Pattern = /^[0-9a-f]{32}$/i;
+function createFetchGuid(storage, options) {
+  return () => fetchGuidWithStorage(storage, options);
+}
+function fetchGuidWithStorage(storage, options) {
+  const key = options?.key ?? defaultKey;
+  const current = safeGet(storage, key);
+  if (current) {
+    const unmasked = unmaskGuid(current);
+    if (unmasked) return formatGuid(unmasked, options);
+  }
+  const guid = generateGuid();
+  safeSet(storage, key, maskGuid(guid));
+  return formatGuid(guid, options);
+}
+function safeGet(storage, key) {
+  try {
+    return storage.get(key);
+  } catch {
+    return null;
+  }
+}
+function safeSet(storage, key, value) {
+  try {
+    storage.set(key, value);
+  } catch {
+    return;
+  }
+}
+function generateGuid() {
+  const cryptoObj = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+  if (cryptoObj && cryptoObj.getRandomValues) {
+    return "10000000-1000-4000-8000-100000000000".replace(
+      /[018]/g,
+      (c) => (+c ^ cryptoObj.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16)
+    );
+  }
+  return "xxxxxxxx-xxxx-4xxx-8xxx-xxxxxxxxxxxx".replace(/[xy]/g, (ch) => {
+    const r = Math.random() * 16 | 0;
+    const v = ch === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function maskGuid(guid) {
+  const hex = guid.replace(/-/g, "");
+  const buffer = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    buffer[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+  }
+  return base64Encode(buffer);
+}
+function unmaskGuid(value) {
+  const clean = value.replace(/"/g, "").trim();
+  if (guidPattern.test(clean)) return clean;
+  if (hex32Pattern.test(clean)) {
+    return clean.replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "$1-$2-$3-$4-$5");
   }
-  uKey = ((_uKey2 = uKey) == null ? void 0 : _uKey2.replace(/"/g, "")) || "";
-  const buffer = atob(uKey);
-  const hex = Array.prototype.map.call(
-    new Uint8Array(buffer.length).map((_, i) => buffer.charCodeAt(i)),
-    (byte) => ("0" + (byte & 255).toString(16)).slice(-2)
-  ).join("");
+  const bytes = base64Decode(clean);
+  if (!bytes) return null;
+  const hex = Array.prototype.map.call(bytes, (byte) => ("0" + (byte & 255).toString(16)).slice(-2)).join("");
+  if (hex.length !== 32) return null;
   return hex.replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "$1-$2-$3-$4-$5");
-};
-var getLocalItem = (key) => {
-  if (typeof window !== "undefined") {
-    return window.localStorage.getItem(key);
+}
+function formatGuid(guid, options) {
+  const format = options?.format ?? "uuid";
+  const prefix = options?.prefix ?? "";
+  if (format === "uuid") return prefix + guid;
+  const hex = guid.replace(/-/g, "");
+  if (format === "hex") return prefix + hex;
+  const buffer = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    buffer[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+  }
+  return prefix + base64Encode(buffer);
+}
+function base64Encode(bytes) {
+  const btoaFn = typeof globalThis !== "undefined" ? globalThis.btoa : void 0;
+  if (btoaFn) {
+    let binary = "";
+    for (let i2 = 0; i2 < bytes.length; i2++) binary += String.fromCharCode(bytes[i2]);
+    return btoaFn(binary);
+  }
+  const BufferCtor = typeof globalThis !== "undefined" ? globalThis.Buffer : void 0;
+  if (BufferCtor) return BufferCtor.from(bytes).toString("base64");
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  let out = "";
+  let i = 0;
+  while (i < bytes.length) {
+    const rem = bytes.length - i;
+    const b1 = bytes[i++];
+    const b2 = rem > 1 ? bytes[i++] : 0;
+    const b3 = rem > 2 ? bytes[i++] : 0;
+    const n = b1 << 16 | b2 << 8 | b3;
+    out += chars[n >> 18 & 63] + chars[n >> 12 & 63] + (rem > 1 ? chars[n >> 6 & 63] : "=") + (rem > 2 ? chars[n & 63] : "=");
+  }
+  return out;
+}
+function base64Decode(b64) {
+  const atobFn = typeof globalThis !== "undefined" ? globalThis.atob : void 0;
+  if (atobFn) {
+    try {
+      const bin = atobFn(b64);
+      const out = new Uint8Array(bin.length);
+      for (let i2 = 0; i2 < bin.length; i2++) out[i2] = bin.charCodeAt(i2);
+      return out;
+    } catch {
+      return null;
+    }
+  }
+  const BufferCtor = typeof globalThis !== "undefined" ? globalThis.Buffer : void 0;
+  if (BufferCtor) {
+    try {
+      const buf = BufferCtor.from(b64, "base64");
+      return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    } catch {
+      return null;
+    }
+  }
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  const map = {};
+  for (let i2 = 0; i2 < chars.length; i2++) map[chars[i2]] = i2;
+  const clean = b64.replace(/[^A-Za-z0-9+/=]/g, "");
+  if (!clean) return null;
+  const bytes = [];
+  let i = 0;
+  while (i < clean.length) {
+    const c1 = clean[i++];
+    const c2 = clean[i++];
+    const c3 = clean[i++];
+    const c4 = clean[i++];
+    if (!c1 || !c2) break;
+    const e1 = map[c1];
+    const e2 = map[c2];
+    if (e1 === void 0 || e2 === void 0) return null;
+    const e3 = c3 === "=" || !c3 ? 0 : map[c3];
+    const e4 = c4 === "=" || !c4 ? 0 : map[c4];
+    if (e3 === void 0 || e4 === void 0) return null;
+    const n = e1 << 18 | e2 << 12 | e3 << 6 | e4;
+    const b1 = n >> 16 & 255;
+    const b2 = n >> 8 & 255;
+    const b3 = n & 255;
+    bytes.push(b1);
+    if (c3 !== "=") bytes.push(b2);
+    if (c4 !== "=") bytes.push(b3);
+  }
+  return new Uint8Array(bytes);
+}
+
+// src/utils/uniqueKey.ts
+var memoryStore = /* @__PURE__ */ new Map();
+var memoryStorage = {
+  get(key) {
+    return memoryStore.get(key) ?? null;
+  },
+  set(key, val) {
+    memoryStore.set(key, val);
   }
 };
-var setLocalItem = (key, val) => {
-  if (typeof window !== "undefined") {
-    window.localStorage.setItem(key, val);
+var defaultStorage = {
+  get(key) {
+    return webStorage.get(key) ?? memoryStorage.get(key);
+  },
+  set(key, val) {
+    webStorage.set(key, val);
+    memoryStorage.set(key, val);
   }
 };
+var storageAdapter = defaultStorage;
+var fetchGuidImpl = createFetchGuid(storageAdapter);
+var setUniqueKeyStorage = (adapter) => {
+  storageAdapter = adapter ?? defaultStorage;
+  fetchGuidImpl = createFetchGuid(storageAdapter);
+};
+var fetchGuid = () => fetchGuidImpl();
 
 // src/index.ts
 var api;
@@ -4882,6 +5343,7 @@ function createApiServiceClient(service) {
 0 && (module.exports = {
   apiError,
   callApi,
+  createFetchGuid,
   destroySDK,
   fetchGuid,
   getSDK,
@@ -4889,6 +5351,8 @@ function createApiServiceClient(service) {
   initSDK,
   notify,
   requestApi,
-  requestApiSpec
+  requestApiSpec,
+  setUniqueKeyStorage,
+  webStorage
 });
 //# sourceMappingURL=index.cjs.map