openxiangda 1.0.164 → 1.0.166

package/packages/sdk/dist/runtime/react.cjs

@@ -8955,6 +8955,8 @@ var resolveAppTypeFromLocation = () => {
 var import_react20 = require("react");
 
 // packages/sdk/src/runtime/core/publicAccess.ts
+var PUBLIC_SESSION_RENEW_WINDOW_MS = 5 * 60 * 1e3;
+var publicSessionInflight = /* @__PURE__ */ new Map();
 var PublicAccessClientError = class extends Error {
   constructor(message3, options = {}) {
     super(message3);
@@ -8982,48 +8984,144 @@ var createPublicAccessClient = ({
       userAgent: input.userAgent || getCurrentUserAgent(),
       guestIdentifier: input.guestIdentifier || getOrCreatePublicGuestIdentifier(normalizedAppType)
     };
-    const response = await boundFetch(
-      buildServiceUrl3(
-        servicePrefix,
-        `/openxiangda-api/v1/apps/${encodeURIComponent(
-          normalizedAppType
-        )}/public/session`
-      ),
-      {
-        method: "POST",
-        credentials: "include",
-        headers: {
-          accept: "application/json",
-          "content-type": "application/json"
-        },
-        body: JSON.stringify(body)
-      }
+    const identity = buildPublicSessionIdentity(
+      normalizedAppType,
+      servicePrefix,
+      body
     );
-    const payload = await readPayload2(response);
-    const code = getRecordValue3(payload, "code");
-    const success = getRecordValue3(payload, "success");
-    if (!response.ok || success === false || !isSuccessCode7(code)) {
-      throw new PublicAccessClientError(
-        String(
-          getRecordValue3(payload, "message") || `Public access session failed: ${response.status}`
+    const cached = readCachedPublicSession(identity);
+    if (cached) return cached;
+    const existing = publicSessionInflight.get(identity);
+    if (existing) return existing;
+    const pending = (async () => {
+      const response = await boundFetch(
+        buildServiceUrl3(
+          servicePrefix,
+          `/openxiangda-api/v1/apps/${encodeURIComponent(
+            normalizedAppType
+          )}/public/session`
         ),
-        { status: response.status, code, payload }
+        {
+          method: "POST",
+          credentials: "include",
+          headers: {
+            accept: "application/json",
+            "content-type": "application/json"
+          },
+          body: JSON.stringify(body)
+        }
       );
+      const payload = await readPayload2(response);
+      const code = getRecordValue3(payload, "code");
+      const success = getRecordValue3(payload, "success");
+      if (!response.ok || success === false || !isSuccessCode7(code)) {
+        throw new PublicAccessClientError(
+          String(
+            getRecordValue3(payload, "message") || `Public access session failed: ${response.status}`
+          ),
+          { status: response.status, code, payload }
+        );
+      }
+      const data = getRecordValue3(payload, "data");
+      const extra = getRecordValue3(payload, "extra");
+      const session = {
+        ...data,
+        publicAccess: extra?.publicAccess || null,
+        raw: payload
+      };
+      writeCachedPublicSession(identity, session);
+      return session;
+    })();
+    publicSessionInflight.set(identity, pending);
+    try {
+      return await pending;
+    } finally {
+      if (publicSessionInflight.get(identity) === pending) {
+        publicSessionInflight.delete(identity);
+      }
     }
-    const data = getRecordValue3(payload, "data");
-    const extra = getRecordValue3(payload, "extra");
-    return {
-      ...data,
-      publicAccess: extra?.publicAccess || null,
-      raw: payload
-    };
   };
   return {
     appType: normalizedAppType,
     servicePrefix,
-    startSession: request
+    startSession: request,
+    clearSession: (input = {}) => {
+      const body = {
+        ...input,
+        path: input.path || getCurrentPathname2(),
+        domain: input.domain || getCurrentDomain(),
+        userAgent: input.userAgent || getCurrentUserAgent(),
+        guestIdentifier: input.guestIdentifier || getOrCreatePublicGuestIdentifier(normalizedAppType)
+      };
+      clearCachedPublicSession(
+        buildPublicSessionIdentity(normalizedAppType, servicePrefix, body)
+      );
+    }
   };
 };
+var buildPublicSessionIdentity = (appType, servicePrefix, input) => JSON.stringify({
+  appType,
+  servicePrefix: servicePrefix.replace(/\/$/, ""),
+  path: input.path || "",
+  policyCode: input.policyCode || "",
+  routeCode: input.routeCode || "",
+  ticket: input.ticket || "",
+  guestIdentifier: input.guestIdentifier || "",
+  domain: input.domain || ""
+});
+var publicSessionStorageKey = (identity) => {
+  let hash = 2166136261;
+  for (let index = 0; index < identity.length; index += 1) {
+    hash ^= identity.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `openxiangda:public:session:v1:${identity.length}:${(hash >>> 0).toString(16)}`;
+};
+var readCachedPublicSession = (identity) => {
+  try {
+    if (typeof window === "undefined" || !window.sessionStorage) return null;
+    const raw = window.sessionStorage.getItem(publicSessionStorageKey(identity));
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (parsed.identity !== identity || !parsed.session) return null;
+    if (!isPublicSessionReusable(parsed.session)) {
+      clearCachedPublicSession(identity);
+      return null;
+    }
+    return parsed.session;
+  } catch {
+    return null;
+  }
+};
+var writeCachedPublicSession = (identity, session) => {
+  if (!isPublicSessionReusable(session)) return;
+  try {
+    if (typeof window === "undefined" || !window.sessionStorage) return;
+    const { raw: _raw, ...cacheableSession } = session;
+    window.sessionStorage.setItem(
+      publicSessionStorageKey(identity),
+      JSON.stringify({ identity, session: cacheableSession })
+    );
+  } catch {
+  }
+};
+var clearCachedPublicSession = (identity) => {
+  try {
+    if (typeof window !== "undefined" && window.sessionStorage) {
+      window.sessionStorage.removeItem(publicSessionStorageKey(identity));
+    }
+  } catch {
+  }
+};
+var isPublicSessionReusable = (session) => {
+  const accessTokenExpiresAt = Number(session.accessTokenExpiresAt);
+  if (!Number.isFinite(accessTokenExpiresAt) || accessTokenExpiresAt <= 0) {
+    return false;
+  }
+  const policyExpiresAt = session.publicAccess?.expiresAt ? new Date(session.publicAccess.expiresAt).getTime() : Number.POSITIVE_INFINITY;
+  const expiresAt = Math.min(accessTokenExpiresAt, policyExpiresAt);
+  return expiresAt - Date.now() >= PUBLIC_SESSION_RENEW_WINDOW_MS;
+};
 var buildServiceUrl3 = (servicePrefix, path) => {
   const prefix = servicePrefix.endsWith("/") ? servicePrefix.slice(0, -1) : servicePrefix;
   const suffix = path.startsWith("/") ? path : `/${path}`;
@@ -9106,29 +9204,40 @@ var usePublicAccess = (options = {}) => {
       setError(null);
       try {
         const resolvedPath = input.path || stableSessionInput.path || readPathFromLocation();
-        const data = await client.startSession({
+        const resolvedInput = {
           ...stableSessionInput,
           ...input,
           ticket: input.ticket || stableSessionInput.ticket || readTicketFromLocation(),
           path: resolvedPath
-        });
-        if (!mountedRef.current) return data;
-        activeSessionRef.current = {
-          accessToken: data.accessToken,
-          path: resolvedPath
         };
-        setSession(data);
-        setAccessToken(data.accessToken, {
-          scope: "public",
-          path: resolvedPath
-        });
-        await reloadRuntime({
-          accessToken: data.accessToken,
-          accessTokenOptions: {
+        let data = await client.startSession(resolvedInput);
+        if (!mountedRef.current) return data;
+        const activateSession = async (next) => {
+          activeSessionRef.current = {
+            accessToken: next.accessToken,
+            path: resolvedPath
+          };
+          setSession(next);
+          setAccessToken(next.accessToken, {
             scope: "public",
             path: resolvedPath
-          }
-        });
+          });
+          await reloadRuntime({
+            accessToken: next.accessToken,
+            accessTokenOptions: {
+              scope: "public",
+              path: resolvedPath
+            }
+          });
+        };
+        try {
+          await activateSession(data);
+        } catch (activationError) {
+          if (!isUnauthorizedPublicSessionError(activationError)) throw activationError;
+          client.clearSession(resolvedInput);
+          data = await client.startSession(resolvedInput);
+          await activateSession(data);
+        }
         if (!mountedRef.current) return data;
         setLoading(false);
         return data;
@@ -9190,4 +9299,11 @@ var readTicketFromLocation = () => {
   return new URLSearchParams(window.location.search).get("ticket") || void 0;
 };
 var readPathFromLocation = () => typeof window === "undefined" ? void 0 : window.location.pathname;
+var isUnauthorizedPublicSessionError = (error) => {
+  if (!error || typeof error !== "object") return false;
+  const status = Number(
+    error.status ?? error.statusCode
+  );
+  return status === 401 || status === 403;
+};
 //# sourceMappingURL=react.cjs.map