@thor-commerce/app-bridge-react 0.7.2 → 0.8.0

package/dist/{chunk-XPUL72AN.js → chunk-IRTDLWEQ.js}

@@ -7,6 +7,7 @@ var EMBEDDED_LAUNCH_PARAMS = [
   "id_token",
   "link_source",
   "locale",
+  "project",
   "protocol",
   "session",
   "shop",
@@ -72,6 +73,37 @@ function sanitizeEmbeddedAppPath(path) {
   }
   return `${url.pathname}${url.search}${url.hash}`;
 }
+function preserveEmbeddedAppLaunchParams(path, currentHref) {
+  if (!path || !currentHref) {
+    return path;
+  }
+  try {
+    const currentUrl = new URL(currentHref, NAVIGATION_BASE_URL);
+    const nextUrl = new URL(path, currentUrl.href);
+    if (nextUrl.origin !== currentUrl.origin) {
+      return path;
+    }
+    let changed = false;
+    for (const key of EMBEDDED_LAUNCH_PARAMS) {
+      if (!nextUrl.searchParams.has(key) && currentUrl.searchParams.has(key)) {
+        const value = currentUrl.searchParams.get(key);
+        if (value != null) {
+          nextUrl.searchParams.set(key, value);
+          changed = true;
+        }
+      }
+    }
+    if (!changed) {
+      return path;
+    }
+    if (/^https?:\/\//i.test(path)) {
+      return nextUrl.toString();
+    }
+    return `${nextUrl.pathname}${nextUrl.search}${nextUrl.hash}`;
+  } catch {
+    return path;
+  }
+}
 function resolveLocalNavigationPath(href, currentOrigin) {
   if (!href || href.startsWith("#")) {
     return null;
@@ -146,13 +178,6 @@ function normalizeBridgeNavigationItems(items) {
 }
 
 // src/core.ts
-var PRESERVED_EMBEDDED_DOCUMENT_PARAMS = [
-  "hmac",
-  "id_token",
-  "project",
-  "tenant",
-  "timestamp"
-];
 var DEFAULT_NAMESPACE = "thorcommerce:app-bridge";
 var DEFAULT_TIMEOUT_MS = 1e4;
 var DEFAULT_REDIRECT_EVENT_TYPE = "navigation:redirect";
@@ -466,273 +491,162 @@ var AppBridge = class {
       throw new Error("AppBridge could not resolve a browser window for redirect.");
     }
     this.selfWindow.location.assign(
-      preserveEmbeddedDocumentParams(destination, this.selfWindow.location.href)
+      preserveEmbeddedAppLaunchParams(destination, this.selfWindow.location.href) ?? destination
     );
   }
 };
-function preserveEmbeddedDocumentParams(destination, currentHref) {
-  try {
-    const currentUrl = new URL(currentHref);
-    const nextUrl = new URL(destination, currentUrl.href);
-    if (nextUrl.origin !== currentUrl.origin) {
-      return destination;
-    }
-    let changed = false;
-    for (const key of PRESERVED_EMBEDDED_DOCUMENT_PARAMS) {
-      if (!nextUrl.searchParams.has(key) && currentUrl.searchParams.has(key)) {
-        const value = currentUrl.searchParams.get(key);
-        if (value != null) {
-          nextUrl.searchParams.set(key, value);
-          changed = true;
-        }
-      }
-    }
-    return changed ? nextUrl.toString() : destination;
-  } catch {
-    return destination;
-  }
-}
 function createAppBridge(options = {}) {
   return new AppBridge(options);
 }
 
-// src/react.tsx
-import {
-  createContext,
-  useContext,
-  useEffect,
-  useMemo,
-  useRef,
-  useState
-} from "react";
-import { jsx } from "react/jsx-runtime";
-var AppBridgeContext = createContext(null);
-function AppBridgeProvider({
-  children,
-  clientId,
-  currentPath,
-  navigationItems,
-  navigationEventType = "navigation:go",
-  navigationUpdateEventType = "navigation:update",
-  namespace,
-  onNavigate,
-  readyEventType = "app:ready",
-  readyPayload,
-  requestTimeoutMs,
-  selfWindow,
-  targetOrigin,
-  targetWindow
-}) {
-  const [bridge, setBridge] = useState(null);
-  const onNavigateRef = useRef(onNavigate);
-  const normalizedNavigationItems = useMemo(
-    () => normalizeBridgeNavigationItems(navigationItems),
-    [navigationItems]
-  );
-  const sessionTokenCacheRef = useRef(null);
-  const projectRef = useRef(readInitialProject(selfWindow));
-  const pendingSessionTokenRef = useRef(null);
-  useEffect(() => {
-    onNavigateRef.current = onNavigate;
-  }, [onNavigate]);
-  useEffect(() => {
-    if (typeof window === "undefined" && !selfWindow) {
-      return;
-    }
-    const resolvedTargetOrigin = targetOrigin ?? getReferrerOrigin(selfWindow);
-    const resolvedAllowedOrigins = resolvedTargetOrigin ? [resolvedTargetOrigin] : void 0;
-    const nextBridge = createAppBridge({
-      allowedOrigins: resolvedAllowedOrigins,
-      clientId,
-      namespace,
-      requestTimeoutMs,
-      selfWindow,
+// src/runtime.ts
+var GLOBAL_RUNTIME_KEY = "__thorEmbeddedAppRuntime__";
+var THOR_NAVIGATE_EVENT = "thor:navigate";
+var EmbeddedAppRuntime = class {
+  constructor(config) {
+    this.currentPath = null;
+    this.navigationItems = [];
+    this.navigationEventType = "navigation:go";
+    this.navigationUpdateEventType = "navigation:update";
+    this.readyEventType = "app:ready";
+    this.sessionTokenCache = null;
+    this.pendingSessionToken = null;
+    const resolvedWindow = config.selfWindow ?? (typeof window !== "undefined" ? window : void 0);
+    if (!resolvedWindow) {
+      throw new Error("EmbeddedAppRuntime requires a browser window.");
+    }
+    this.selfWindow = resolvedWindow;
+    this.targetOrigin = config.targetOrigin ?? getReferrerOrigin(resolvedWindow);
+    this.clientId = config.clientId;
+    this.project = readInitialProject(resolvedWindow);
+    this.readyPayload = config.readyPayload ?? { clientId: config.clientId };
+    this.bridge = createAppBridge({
+      allowedOrigins: this.targetOrigin ? [this.targetOrigin] : void 0,
+      namespace: config.namespace,
+      requestTimeoutMs: config.requestTimeoutMs,
+      selfWindow: resolvedWindow,
       source: "embedded-app",
       target: "dashboard",
-      targetOrigin: resolvedTargetOrigin,
-      targetWindow
-    });
-    setBridge(nextBridge);
-    return () => {
-      setBridge((currentBridge) => currentBridge === nextBridge ? null : currentBridge);
-      nextBridge.destroy();
-    };
-  }, [
-    clientId,
-    namespace,
-    requestTimeoutMs,
-    selfWindow,
-    targetOrigin,
-    targetWindow
-  ]);
-  useEffect(() => {
-    if (!bridge || !bridge.hasTargetWindow()) {
-      return;
-    }
-    bridge.send(
-      readyEventType,
-      readyPayload ?? {
-        clientId
-      }
-    );
-  }, [bridge, clientId, readyEventType, readyPayload]);
-  useEffect(() => {
-    if (!bridge || !bridge.hasTargetWindow()) {
-      return;
-    }
-    bridge.send("navigation:items:update", {
-      items: normalizedNavigationItems
+      targetOrigin: this.targetOrigin,
+      targetWindow: config.targetWindow
     });
-  }, [bridge, normalizedNavigationItems]);
-  useEffect(() => {
-    if (!bridge || !bridge.hasTargetWindow() || !currentPath) {
-      return;
-    }
-    bridge.send(navigationUpdateEventType, buildNavigationUpdatePayload(currentPath));
-  }, [bridge, currentPath, navigationUpdateEventType]);
-  useEffect(() => {
-    if (!bridge || !onNavigate) {
-      return;
-    }
-    return bridge.on(navigationEventType, (message) => {
+    this.removeNavigationRequestHandler = this.bridge.on(this.navigationEventType, (message) => {
       const destination = resolveNavigationDestination(message.payload);
       if (!destination) {
         return;
       }
-      onNavigateRef.current?.(destination, message);
+      const nextPath = preserveEmbeddedAppLaunchParams(
+        destination,
+        this.selfWindow.location.href
+      );
+      this.navigate(nextPath ?? destination, message);
     });
-  }, [bridge, navigationEventType, onNavigate]);
-  useEffect(() => {
-    if (!bridge || !onNavigate || typeof document === "undefined" || typeof window === "undefined") {
-      return;
-    }
-    const handleLocalNavigation = (path) => {
-      const sanitizedPath = sanitizeEmbeddedAppPath(path);
-      if (!sanitizedPath) {
-        return;
-      }
-      onNavigateRef.current?.(sanitizedPath);
-    };
-    const handleDocumentClick = (event) => {
-      if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.altKey || event.ctrlKey || event.shiftKey) {
-        return;
-      }
-      const target = event.target;
-      if (!(target instanceof Element)) {
-        return;
-      }
-      const anchor = target.closest("a[href]");
-      if (!(anchor instanceof HTMLAnchorElement)) {
-        return;
-      }
-      if (anchor.hasAttribute("download")) {
-        return;
-      }
-      const targetWindow2 = anchor.target.toLowerCase();
-      const href = anchor.getAttribute("href");
-      if (!href) {
-        return;
-      }
-      if (targetWindow2 === "_top" || targetWindow2 === "_parent") {
-        event.preventDefault();
-        bridge.redirectToRemote(anchor.href);
-        return;
-      }
-      if (targetWindow2 && targetWindow2 !== "_self") {
-        return;
-      }
-      const nextPath = resolveLocalNavigationPath(href, window.location.origin);
-      if (!nextPath) {
-        return;
-      }
-      event.preventDefault();
-      handleLocalNavigation(nextPath);
-    };
-    const originalOpen = window.open.bind(window);
-    window.open = (url, target, features) => {
-      if (url == null) {
-        return originalOpen(url, target, features);
-      }
-      const href = typeof url === "string" ? url : url.toString();
-      const targetName = (target ?? "").toLowerCase();
-      if (targetName === "_top" || targetName === "_parent") {
-        bridge.redirectToRemote(new URL(href, window.location.href).toString());
-        return null;
+    this.removeNavigationInterceptors = installNavigationInterceptors({
+      bridge: this.bridge,
+      selfWindow: this.selfWindow,
+      navigate: (path) => this.navigate(path)
+    });
+    this.restoreFetch = installFetchInterceptor({
+      bridge: this.bridge,
+      getClientId: () => this.clientId,
+      getProject: () => this.project,
+      setProject: (project) => {
+        this.project = project;
+      },
+      readCachedToken: () => this.sessionTokenCache,
+      writeCachedToken: (token) => {
+        this.sessionTokenCache = token;
+      },
+      readPendingToken: () => this.pendingSessionToken,
+      writePendingToken: (token) => {
+        this.pendingSessionToken = token;
       }
-      if (!targetName || targetName === "_self") {
-        const nextPath = resolveLocalNavigationPath(href, window.location.origin);
-        if (nextPath) {
-          handleLocalNavigation(nextPath);
-          return window;
-        }
+    });
+    this.update(config);
+  }
+  update(config) {
+    if (config.clientId) {
+      this.clientId = config.clientId;
+      if (!this.readyPayload || typeof this.readyPayload === "object" && this.readyPayload !== null && "clientId" in this.readyPayload) {
+        this.readyPayload = config.readyPayload ?? { clientId: config.clientId };
       }
-      return originalOpen(url, target, features);
-    };
-    document.addEventListener("click", handleDocumentClick, true);
-    return () => {
-      document.removeEventListener("click", handleDocumentClick, true);
-      window.open = originalOpen;
-    };
-  }, [bridge, onNavigate]);
-  useEffect(() => {
-    if (!bridge || typeof window === "undefined") {
+    }
+    if (config.currentPath !== void 0) {
+      this.currentPath = config.currentPath;
+    }
+    if (config.navigationItems !== void 0) {
+      this.navigationItems = normalizeBridgeNavigationItems(config.navigationItems);
+    }
+    if (config.onNavigate !== void 0) {
+      this.onNavigate = config.onNavigate;
+    }
+    if (config.readyEventType) {
+      this.readyEventType = config.readyEventType;
+    }
+    if (config.readyPayload !== void 0) {
+      this.readyPayload = config.readyPayload;
+    }
+    if (config.targetWindow !== void 0) {
+      this.bridge.setTargetWindow(config.targetWindow ?? null);
+    }
+    this.syncBridgeState();
+  }
+  clearNavigationHandler() {
+    this.onNavigate = void 0;
+  }
+  destroy() {
+    this.removeNavigationRequestHandler?.();
+    this.removeNavigationInterceptors();
+    this.restoreFetch();
+    this.bridge.destroy();
+  }
+  syncBridgeState() {
+    if (!this.bridge.hasTargetWindow()) {
       return;
     }
-    const originalFetch = globalThis.fetch.bind(globalThis);
-    const interceptedFetch = async (input, init) => {
-      if (!shouldAttachSessionToken(input)) {
-        return originalFetch(input, init);
-      }
-      const existingAuthorization = getExistingAuthorization(input, init);
-      if (existingAuthorization) {
-        return originalFetch(input, init);
-      }
-      const nextHeaders = new Headers(
-        input instanceof Request ? input.headers : init?.headers
+    this.bridge.send(this.readyEventType, this.readyPayload);
+    this.bridge.send("navigation:items:update", {
+      items: this.navigationItems
+    });
+    if (this.currentPath) {
+      this.bridge.send(
+        this.navigationUpdateEventType,
+        buildNavigationUpdatePayload(this.currentPath)
       );
-      if (projectRef.current && !nextHeaders.has("X-Thor-Project")) {
-        nextHeaders.set("X-Thor-Project", projectRef.current);
-      }
-      try {
-        const sessionToken = await getSessionToken({
-          bridge,
-          clientId,
-          pendingSessionTokenRef,
-          projectRef,
-          sessionTokenCacheRef
-        });
-        nextHeaders.set("Authorization", `Bearer ${sessionToken}`);
-      } catch {
-        if (!projectRef.current) {
-          throw new Error("Missing Thor embedded session token");
-        }
-      }
-      if (!nextHeaders.has("X-Requested-With")) {
-        nextHeaders.set("X-Requested-With", "XMLHttpRequest");
-      }
-      if (input instanceof Request) {
-        return originalFetch(
-          new Request(input, {
-            headers: nextHeaders
-          })
-        );
-      }
-      return originalFetch(input, {
-        ...init,
-        headers: nextHeaders
-      });
-    };
-    globalThis.fetch = interceptedFetch;
-    window.fetch = interceptedFetch;
-    return () => {
-      globalThis.fetch = originalFetch;
-      window.fetch = originalFetch;
-    };
-  }, [bridge, clientId]);
-  return /* @__PURE__ */ jsx(AppBridgeContext.Provider, { value: bridge, children });
+    }
+  }
+  navigate(path, message) {
+    if (this.onNavigate) {
+      this.onNavigate(path, message);
+      return;
+    }
+    if (dispatchNavigateEvent(this.selfWindow.document, path)) {
+      return;
+    }
+    this.selfWindow.location.assign(path);
+  }
+};
+function getOrCreateEmbeddedAppRuntime(config) {
+  const globalScope = globalThis;
+  const existingRuntime = globalScope[GLOBAL_RUNTIME_KEY];
+  if (existingRuntime) {
+    existingRuntime.update(config);
+    return existingRuntime;
+  }
+  const runtime = new EmbeddedAppRuntime(config);
+  globalScope[GLOBAL_RUNTIME_KEY] = runtime;
+  return runtime;
 }
-function useAppBridge() {
-  return useContext(AppBridgeContext);
+function getEmbeddedAppRuntime() {
+  return globalThis[GLOBAL_RUNTIME_KEY] ?? null;
+}
+function dispatchNavigateEvent(document, path) {
+  const event = new CustomEvent(THOR_NAVIGATE_EVENT, {
+    cancelable: true,
+    detail: { path }
+  });
+  document.dispatchEvent(event);
+  return event.defaultPrevented;
 }
 function getReferrerOrigin(explicitWindow) {
   const resolvedWindow = explicitWindow ?? (typeof window !== "undefined" ? window : void 0);
@@ -746,40 +660,190 @@ function getReferrerOrigin(explicitWindow) {
     return void 0;
   }
 }
+function installNavigationInterceptors({
+  bridge,
+  selfWindow,
+  navigate
+}) {
+  const document = selfWindow.document;
+  const handleLocalNavigation = (path) => {
+    const sanitizedPath = sanitizeEmbeddedAppPath(path);
+    if (!sanitizedPath) {
+      return;
+    }
+    const nextPath = preserveEmbeddedAppLaunchParams(
+      sanitizedPath,
+      selfWindow.location.href
+    );
+    navigate(nextPath ?? sanitizedPath);
+  };
+  const handleDocumentClick = (event) => {
+    if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.altKey || event.ctrlKey || event.shiftKey) {
+      return;
+    }
+    const target = event.target;
+    if (!(target instanceof Element)) {
+      return;
+    }
+    const anchor = target.closest("a[href]");
+    if (!(anchor instanceof HTMLAnchorElement)) {
+      return;
+    }
+    if (anchor.hasAttribute("download")) {
+      return;
+    }
+    const targetWindow = anchor.target.toLowerCase();
+    const href = anchor.getAttribute("href");
+    if (!href) {
+      return;
+    }
+    if (targetWindow === "_top" || targetWindow === "_parent") {
+      event.preventDefault();
+      bridge.redirectToRemote(anchor.href);
+      return;
+    }
+    if (targetWindow && targetWindow !== "_self") {
+      return;
+    }
+    const nextPath = resolveLocalNavigationPath(href, selfWindow.location.origin);
+    if (!nextPath) {
+      return;
+    }
+    event.preventDefault();
+    handleLocalNavigation(nextPath);
+  };
+  const originalOpen = selfWindow.open.bind(selfWindow);
+  selfWindow.open = (url, target, features) => {
+    if (url == null) {
+      return originalOpen(url, target, features);
+    }
+    const href = typeof url === "string" ? url : url.toString();
+    const targetName = (target ?? "").toLowerCase();
+    if (targetName === "_top" || targetName === "_parent") {
+      bridge.redirectToRemote(new URL(href, selfWindow.location.href).toString());
+      return null;
+    }
+    if (!targetName || targetName === "_self") {
+      const nextPath = resolveLocalNavigationPath(
+        href,
+        selfWindow.location.origin
+      );
+      if (nextPath) {
+        handleLocalNavigation(nextPath);
+        return selfWindow;
+      }
+    }
+    return originalOpen(url, target, features);
+  };
+  document.addEventListener("click", handleDocumentClick, true);
+  return () => {
+    document.removeEventListener("click", handleDocumentClick, true);
+    selfWindow.open = originalOpen;
+  };
+}
+function installFetchInterceptor({
+  bridge,
+  getClientId,
+  getProject,
+  setProject,
+  readCachedToken,
+  writeCachedToken,
+  readPendingToken,
+  writePendingToken
+}) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  const originalFetch = globalThis.fetch.bind(globalThis);
+  const interceptedFetch = async (input, init) => {
+    if (!shouldAttachSessionToken(input)) {
+      return originalFetch(input, init);
+    }
+    const existingAuthorization = getExistingAuthorization(input, init);
+    if (existingAuthorization) {
+      return originalFetch(input, init);
+    }
+    const nextHeaders = new Headers(
+      input instanceof Request ? input.headers : init?.headers
+    );
+    try {
+      const sessionToken = await getSessionToken({
+        bridge,
+        clientId: getClientId(),
+        project: getProject,
+        setProject,
+        readCachedToken,
+        writeCachedToken,
+        readPendingToken,
+        writePendingToken
+      });
+      nextHeaders.set("Authorization", `Bearer ${sessionToken}`);
+    } catch {
+      if (!getProject()) {
+        throw new Error("Missing Thor embedded session token");
+      }
+    }
+    if (!nextHeaders.has("X-Requested-With")) {
+      nextHeaders.set("X-Requested-With", "XMLHttpRequest");
+    }
+    if (input instanceof Request) {
+      return originalFetch(
+        new Request(input, {
+          headers: nextHeaders
+        })
+      );
+    }
+    return originalFetch(input, {
+      ...init,
+      headers: nextHeaders
+    });
+  };
+  globalThis.fetch = interceptedFetch;
+  window.fetch = interceptedFetch;
+  return () => {
+    globalThis.fetch = originalFetch;
+    window.fetch = originalFetch;
+  };
+}
 async function getSessionToken({
   bridge,
   clientId,
-  pendingSessionTokenRef,
-  projectRef,
-  sessionTokenCacheRef
+  project,
+  setProject,
+  readCachedToken,
+  writeCachedToken,
+  readPendingToken,
+  writePendingToken
 }) {
-  const cachedToken = sessionTokenCacheRef.current;
+  const cachedToken = readCachedToken();
   if (cachedToken && !isExpired(cachedToken.expiresAt)) {
     return cachedToken.token;
   }
-  if (pendingSessionTokenRef.current) {
-    return pendingSessionTokenRef.current;
+  const pendingToken = readPendingToken();
+  if (pendingToken) {
+    return pendingToken;
   }
-  const pendingToken = bridge.getSessionToken({ clientId }).then((response) => {
+  const nextPendingToken = bridge.getSessionToken({ clientId }).then((response) => {
     const token = response.sessionToken ?? response.idToken;
     if (!token) {
       throw new Error("Missing Thor embedded session token");
     }
     if (response.project) {
-      projectRef.current = response.project;
+      setProject(response.project);
     }
-    sessionTokenCacheRef.current = {
+    writeCachedToken({
       token,
       expiresAt: normalizeTokenExpiry(token, response.exp)
-    };
-    pendingSessionTokenRef.current = null;
+    });
+    writePendingToken(null);
     return token;
   }).catch((error) => {
-    pendingSessionTokenRef.current = null;
+    writePendingToken(null);
     throw error;
   });
-  pendingSessionTokenRef.current = pendingToken;
-  return pendingToken;
+  writePendingToken(nextPendingToken);
+  return nextPendingToken;
 }
 function shouldAttachSessionToken(input) {
   if (typeof window === "undefined") {
@@ -850,6 +914,7 @@ export {
   EMBEDDED_LAUNCH_PARAMS,
   buildNavigationUpdatePayload,
   sanitizeEmbeddedAppPath,
+  preserveEmbeddedAppLaunchParams,
   resolveLocalNavigationPath,
   resolveNavigationDestination,
   normalizeBridgeNavigationItem,
@@ -857,7 +922,9 @@ export {
   isBridgeMessage,
   AppBridge,
   createAppBridge,
-  AppBridgeProvider,
-  useAppBridge
+  THOR_NAVIGATE_EVENT,
+  EmbeddedAppRuntime,
+  getOrCreateEmbeddedAppRuntime,
+  getEmbeddedAppRuntime
 };
-//# sourceMappingURL=chunk-XPUL72AN.js.map
+//# sourceMappingURL=chunk-IRTDLWEQ.js.map