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

package/dist/browser.cjs

@@ -0,0 +1,971 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  ThorAppBridgeBrowser: () => api
+});
+module.exports = __toCommonJS(browser_exports);
+
+// src/navigation.ts
+var EMBEDDED_LAUNCH_PARAMS = [
+  "appLoadId",
+  "embedded",
+  "hmac",
+  "host",
+  "id_token",
+  "link_source",
+  "locale",
+  "project",
+  "protocol",
+  "session",
+  "shop",
+  "tenant",
+  "timestamp"
+];
+var NAVIGATION_BASE_URL = "https://embedded-app.local";
+function normalizeSearch(search) {
+  if (!search) {
+    return "";
+  }
+  return search.startsWith("?") ? search : `?${search}`;
+}
+function normalizeHash(hash) {
+  if (!hash) {
+    return "";
+  }
+  return hash.startsWith("#") ? hash : `#${hash}`;
+}
+function buildNavigationUpdatePayload(path) {
+  const sanitizedPath = sanitizeEmbeddedAppPath(path) ?? path;
+  let pathname = sanitizedPath;
+  let search = "";
+  let hash = "";
+  const hashIndex = pathname.indexOf("#");
+  if (hashIndex >= 0) {
+    hash = pathname.slice(hashIndex);
+    pathname = pathname.slice(0, hashIndex);
+  }
+  const searchIndex = pathname.indexOf("?");
+  if (searchIndex >= 0) {
+    search = pathname.slice(searchIndex);
+    pathname = pathname.slice(0, searchIndex);
+  }
+  return {
+    path: `${pathname || "/"}${search}${hash}`,
+    pathname: pathname || "/",
+    search,
+    hash
+  };
+}
+function sanitizeEmbeddedAppPath(path) {
+  if (!path) {
+    return path;
+  }
+  const trimmedPath = path.trim();
+  if (!trimmedPath) {
+    return trimmedPath;
+  }
+  const url = new URL(trimmedPath, NAVIGATION_BASE_URL);
+  let changed = false;
+  for (const key of EMBEDDED_LAUNCH_PARAMS) {
+    if (url.searchParams.has(key)) {
+      url.searchParams.delete(key);
+      changed = true;
+    }
+  }
+  if (!changed) {
+    return trimmedPath;
+  }
+  if (/^https?:\/\//i.test(trimmedPath)) {
+    return url.toString();
+  }
+  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;
+  }
+  let destination;
+  try {
+    destination = new URL(href, currentOrigin);
+  } catch {
+    return null;
+  }
+  if (destination.origin !== currentOrigin) {
+    return null;
+  }
+  return sanitizeEmbeddedAppPath(
+    `${destination.pathname}${destination.search}${destination.hash}`
+  ) ?? null;
+}
+function resolveNavigationDestination(payload) {
+  if (typeof payload === "string") {
+    return sanitizeEmbeddedAppPath(payload) ?? null;
+  }
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+  const value = payload;
+  if (typeof value.path === "string" && value.path) {
+    return sanitizeEmbeddedAppPath(value.path) ?? null;
+  }
+  if (typeof value.href === "string" && value.href) {
+    return sanitizeEmbeddedAppPath(value.href) ?? null;
+  }
+  if (typeof value.pathname !== "string" || !value.pathname) {
+    return null;
+  }
+  return sanitizeEmbeddedAppPath(
+    `${value.pathname}${normalizeSearch(value.search ?? "")}${normalizeHash(value.hash ?? "")}`
+  ) ?? null;
+}
+function normalizeNavigationItemPath(path) {
+  if (!path) {
+    return null;
+  }
+  const trimmedPath = path.trim();
+  if (!trimmedPath || /^https?:\/\//i.test(trimmedPath)) {
+    return null;
+  }
+  const normalizedPath = trimmedPath.startsWith("/") ? trimmedPath : "/" + trimmedPath;
+  return sanitizeEmbeddedAppPath(normalizedPath) ?? normalizedPath;
+}
+function normalizeBridgeNavigationItem(item) {
+  const label = item.label?.trim();
+  const path = normalizeNavigationItemPath(item.path);
+  if (!label || !path) {
+    return null;
+  }
+  const matchPattern = normalizeNavigationItemPath(item.matchPattern ?? item.path);
+  return {
+    label,
+    path,
+    ...matchPattern ? { matchPattern } : {},
+    ...item.exactMatch !== void 0 ? { exactMatch: item.exactMatch } : {}
+  };
+}
+function normalizeBridgeNavigationItems(items) {
+  if (!items?.length) {
+    return [];
+  }
+  return items.flatMap((item) => {
+    const normalizedItem = normalizeBridgeNavigationItem(item);
+    return normalizedItem ? [normalizedItem] : [];
+  });
+}
+
+// src/core.ts
+var DEFAULT_NAMESPACE = "thorcommerce:app-bridge";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_REDIRECT_EVENT_TYPE = "navigation:redirect";
+function createMessageId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `msg_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function resolveSelfWindow(explicitWindow) {
+  if (explicitWindow) {
+    return explicitWindow;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  return void 0;
+}
+function resolveTargetWindow(selfWindow, targetWindow) {
+  if (targetWindow) {
+    return targetWindow;
+  }
+  if (!selfWindow) {
+    return void 0;
+  }
+  if (selfWindow.parent && selfWindow.parent !== selfWindow) {
+    return selfWindow.parent;
+  }
+  return void 0;
+}
+function isDevelopmentEnvironment() {
+  const nodeEnv = typeof globalThis !== "undefined" && "process" in globalThis ? globalThis.process?.env?.NODE_ENV : void 0;
+  if (nodeEnv) {
+    return nodeEnv !== "production";
+  }
+  return true;
+}
+function hasAllowedOrigin(origin, allowedOrigins) {
+  if (!allowedOrigins || allowedOrigins.length === 0) {
+    return true;
+  }
+  return allowedOrigins.includes(origin);
+}
+function isMessageTarget(value) {
+  return !!value && typeof value.postMessage === "function";
+}
+function omitUndefinedFields(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, fieldValue]) => fieldValue !== void 0)
+  );
+}
+function isBridgeMessage(value, namespace = DEFAULT_NAMESPACE) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const message = value;
+  return message.namespace === namespace && message.version === "1.0" && typeof message.kind === "string" && typeof message.id === "string" && typeof message.type === "string" && typeof message.source === "string";
+}
+var AppBridge = class {
+  constructor(options = {}) {
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.requestHandlers = /* @__PURE__ */ new Map();
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.namespace = options.namespace ?? DEFAULT_NAMESPACE;
+    this.clientId = options.clientId;
+    this.source = options.source ?? "embedded-app";
+    this.target = options.target;
+    this.targetOrigin = options.targetOrigin ?? "*";
+    this.allowedOrigins = options.allowedOrigins;
+    this.defaultTimeoutMs = options.requestTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.selfWindow = resolveSelfWindow(options.selfWindow);
+    this.targetWindow = resolveTargetWindow(this.selfWindow, options.targetWindow);
+    this.messageListener = (event) => {
+      this.handleMessage(event);
+    };
+    if (!this.selfWindow) {
+      throw new Error(
+        "AppBridge requires a browser window. Pass selfWindow explicitly when constructing it outside global window scope."
+      );
+    }
+    if (this.targetOrigin === "*" && isDevelopmentEnvironment()) {
+      console.warn(
+        'AppBridge is using "*" as targetOrigin. Set targetOrigin explicitly for both the dashboard and embedded app in production.'
+      );
+    }
+    this.selfWindow.addEventListener("message", this.messageListener);
+  }
+  setTargetWindow(targetWindow) {
+    this.targetWindow = targetWindow ?? void 0;
+  }
+  hasTargetWindow() {
+    return this.targetWindow !== void 0;
+  }
+  redirect(payload) {
+    const destination = resolveNavigationDestination(payload);
+    if (!destination) {
+      throw new Error("AppBridge redirect requires a valid destination.");
+    }
+    if (!this.targetWindow) {
+      this.navigateSelf(destination);
+      return;
+    }
+    this.postMessage({
+      kind: "event",
+      type: DEFAULT_REDIRECT_EVENT_TYPE,
+      payload: typeof payload === "string" ? { href: payload } : payload
+    });
+  }
+  redirectToRemote(href) {
+    this.redirect({ href });
+  }
+  redirectToApp(path) {
+    this.redirect(typeof path === "string" ? { path } : path);
+  }
+  send(type, payload) {
+    this.postMessage({
+      kind: "event",
+      type,
+      payload
+    });
+  }
+  request(type, payload, options = {}) {
+    const messageId = createMessageId();
+    const timeoutMs = options.timeoutMs ?? this.defaultTimeoutMs;
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.pendingRequests.delete(messageId);
+        reject(new Error(`Bridge request timed out for "${type}" after ${timeoutMs}ms.`));
+      }, timeoutMs);
+      this.pendingRequests.set(messageId, {
+        resolve: (value) => resolve(value),
+        reject,
+        timeoutId
+      });
+      try {
+        this.postMessage({
+          id: messageId,
+          kind: "request",
+          type,
+          payload
+        });
+      } catch (error) {
+        clearTimeout(timeoutId);
+        this.pendingRequests.delete(messageId);
+        reject(error instanceof Error ? error : new Error("Failed to send bridge request."));
+      }
+    });
+  }
+  getSessionToken(request = {}, options = {}) {
+    const resolvedRequest = request.clientId || this.clientId ? {
+      ...request,
+      clientId: request.clientId ?? this.clientId
+    } : request;
+    return this.request(
+      "thor:session-token:get",
+      resolvedRequest,
+      options
+    );
+  }
+  on(type, handler) {
+    const handlers = this.eventHandlers.get(type) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    this.eventHandlers.set(type, handlers);
+    return () => {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.eventHandlers.delete(type);
+      }
+    };
+  }
+  onRequest(type, handler) {
+    this.requestHandlers.set(type, handler);
+    return () => {
+      const registeredHandler = this.requestHandlers.get(type);
+      if (registeredHandler === handler) {
+        this.requestHandlers.delete(type);
+      }
+    };
+  }
+  destroy() {
+    if (this.selfWindow) {
+      this.selfWindow.removeEventListener("message", this.messageListener);
+    }
+    for (const pendingRequest of this.pendingRequests.values()) {
+      clearTimeout(pendingRequest.timeoutId);
+      pendingRequest.reject(new Error("AppBridge destroyed before a response was received."));
+    }
+    this.pendingRequests.clear();
+    this.eventHandlers.clear();
+    this.requestHandlers.clear();
+  }
+  handleMessage(event) {
+    if (!hasAllowedOrigin(event.origin, this.allowedOrigins)) {
+      return;
+    }
+    if (!isBridgeMessage(event.data, this.namespace)) {
+      return;
+    }
+    const message = event.data;
+    if (this.target && message.target && message.target !== this.source) {
+      return;
+    }
+    const receivedMessage = {
+      ...message,
+      origin: event.origin,
+      rawEvent: event
+    };
+    if (message.kind === "event" && message.type === DEFAULT_REDIRECT_EVENT_TYPE && this.handleRedirectMessage(receivedMessage)) {
+      return;
+    }
+    if (message.kind === "response" && message.replyTo) {
+      this.resolvePendingRequest(message.replyTo, message);
+      return;
+    }
+    this.emitHandlers(message.type, receivedMessage);
+    if (message.kind === "request") {
+      void this.handleRequest(receivedMessage);
+    }
+  }
+  emitHandlers(type, message) {
+    const typeHandlers = this.eventHandlers.get(type);
+    if (typeHandlers) {
+      for (const handler of typeHandlers) {
+        handler(message);
+      }
+    }
+    if (type === "*") {
+      return;
+    }
+    const wildcardHandlers = this.eventHandlers.get("*");
+    if (wildcardHandlers) {
+      for (const handler of wildcardHandlers) {
+        handler(message);
+      }
+    }
+  }
+  async handleRequest(message) {
+    const handler = this.requestHandlers.get(message.type);
+    if (!handler) {
+      return;
+    }
+    const replyTarget = isMessageTarget(message.rawEvent.source) ? message.rawEvent.source : this.targetWindow;
+    try {
+      const payload = await handler(message.payload, message);
+      this.postMessage(
+        {
+          kind: "response",
+          type: message.type,
+          payload,
+          replyTo: message.id
+        },
+        replyTarget
+      );
+    } catch (error) {
+      const bridgeError = error instanceof Error ? { code: "request_handler_error", message: error.message } : { code: "request_handler_error", message: "Unknown request handler error." };
+      this.postMessage(
+        {
+          kind: "response",
+          type: message.type,
+          error: bridgeError,
+          replyTo: message.id
+        },
+        replyTarget
+      );
+    }
+  }
+  resolvePendingRequest(messageId, message) {
+    const pendingRequest = this.pendingRequests.get(messageId);
+    if (!pendingRequest) {
+      return;
+    }
+    clearTimeout(pendingRequest.timeoutId);
+    this.pendingRequests.delete(messageId);
+    if (message.error) {
+      pendingRequest.reject(new Error(`${message.error.code}: ${message.error.message}`));
+      return;
+    }
+    pendingRequest.resolve(message.payload);
+  }
+  postMessage(partialMessage, targetWindowOverride) {
+    const targetWindow = targetWindowOverride ?? this.targetWindow;
+    if (!targetWindow) {
+      throw new Error(
+        "AppBridge could not resolve a target window. Pass targetWindow explicitly or call setTargetWindow()."
+      );
+    }
+    const message = omitUndefinedFields({
+      namespace: this.namespace,
+      version: "1.0",
+      id: partialMessage.id ?? createMessageId(),
+      kind: partialMessage.kind,
+      type: partialMessage.type,
+      source: this.source,
+      target: partialMessage.target ?? this.target,
+      payload: partialMessage.payload,
+      replyTo: partialMessage.replyTo,
+      error: partialMessage.error
+    });
+    targetWindow.postMessage(message, this.targetOrigin);
+  }
+  handleRedirectMessage(message) {
+    const destination = resolveNavigationDestination(message.payload);
+    if (!destination) {
+      return false;
+    }
+    this.navigateSelf(destination);
+    return true;
+  }
+  navigateSelf(destination) {
+    if (!this.selfWindow) {
+      throw new Error("AppBridge could not resolve a browser window for redirect.");
+    }
+    this.selfWindow.location.assign(
+      preserveEmbeddedAppLaunchParams(destination, this.selfWindow.location.href) ?? destination
+    );
+  }
+};
+function createAppBridge(options = {}) {
+  return new AppBridge(options);
+}
+
+// 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: this.targetOrigin,
+      targetWindow: config.targetWindow
+    });
+    this.removeNavigationRequestHandler = this.bridge.on(this.navigationEventType, (message) => {
+      const destination = resolveNavigationDestination(message.payload);
+      if (!destination) {
+        return;
+      }
+      const nextPath = preserveEmbeddedAppLaunchParams(
+        destination,
+        this.selfWindow.location.href
+      );
+      this.navigate(nextPath ?? destination, message);
+    });
+    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;
+      }
+    });
+    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 };
+      }
+    }
+    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;
+    }
+    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)
+      );
+    }
+  }
+  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 getEmbeddedAppRuntime() {
+  return globalThis[GLOBAL_RUNTIME_KEY] ?? null;
+}
+function dispatchNavigateEvent(document2, path) {
+  const event = new CustomEvent(THOR_NAVIGATE_EVENT, {
+    cancelable: true,
+    detail: { path }
+  });
+  document2.dispatchEvent(event);
+  return event.defaultPrevented;
+}
+function getReferrerOrigin(explicitWindow) {
+  const resolvedWindow = explicitWindow ?? (typeof window !== "undefined" ? window : void 0);
+  const referrer = resolvedWindow?.document?.referrer;
+  if (!referrer) {
+    return void 0;
+  }
+  try {
+    return new URL(referrer).origin;
+  } catch {
+    return void 0;
+  }
+}
+function installNavigationInterceptors({
+  bridge,
+  selfWindow,
+  navigate
+}) {
+  const document2 = 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);
+  };
+  document2.addEventListener("click", handleDocumentClick, true);
+  return () => {
+    document2.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,
+  project,
+  setProject,
+  readCachedToken,
+  writeCachedToken,
+  readPendingToken,
+  writePendingToken
+}) {
+  const cachedToken = readCachedToken();
+  if (cachedToken && !isExpired(cachedToken.expiresAt)) {
+    return cachedToken.token;
+  }
+  const pendingToken = readPendingToken();
+  if (pendingToken) {
+    return pendingToken;
+  }
+  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) {
+      setProject(response.project);
+    }
+    writeCachedToken({
+      token,
+      expiresAt: normalizeTokenExpiry(token, response.exp)
+    });
+    writePendingToken(null);
+    return token;
+  }).catch((error) => {
+    writePendingToken(null);
+    throw error;
+  });
+  writePendingToken(nextPendingToken);
+  return nextPendingToken;
+}
+function shouldAttachSessionToken(input) {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  const requestUrl = resolveRequestUrl(input);
+  return requestUrl.origin === window.location.origin;
+}
+function resolveRequestUrl(input) {
+  if (input instanceof Request) {
+    return new URL(input.url);
+  }
+  if (input instanceof URL) {
+    return input;
+  }
+  return new URL(input, window.location.href);
+}
+function getExistingAuthorization(input, init) {
+  if (input instanceof Request && input.headers.has("Authorization")) {
+    return input.headers.get("Authorization");
+  }
+  if (!init?.headers) {
+    return null;
+  }
+  return new Headers(init.headers).get("Authorization");
+}
+function normalizeTokenExpiry(token, explicitExp) {
+  const tokenExp = explicitExp ?? decodeJwtExpiry(token);
+  return tokenExp ? tokenExp * 1e3 : void 0;
+}
+function decodeJwtExpiry(token) {
+  const [, payload] = token.split(".");
+  if (!payload || typeof window === "undefined") {
+    return void 0;
+  }
+  try {
+    const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized.padEnd(
+      normalized.length + (4 - normalized.length % 4) % 4,
+      "="
+    );
+    const json = JSON.parse(window.atob(padded));
+    return typeof json.exp === "number" ? json.exp : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isExpired(expiresAt) {
+  if (!expiresAt) {
+    return false;
+  }
+  return Date.now() >= expiresAt - 5e3;
+}
+function readInitialProject(explicitWindow) {
+  const resolvedWindow = explicitWindow ?? (typeof window !== "undefined" ? window : void 0);
+  if (!resolvedWindow) {
+    return null;
+  }
+  try {
+    const url = new URL(resolvedWindow.location.href);
+    return url.searchParams.get("project");
+  } catch {
+    return null;
+  }
+}
+
+// src/browser.ts
+var api = {
+  init(config) {
+    return getOrCreateEmbeddedAppRuntime(config);
+  },
+  getRuntime: getEmbeddedAppRuntime
+};
+if (typeof window !== "undefined") {
+  window.ThorAppBridge = api;
+  const script = document.currentScript;
+  const clientId = script?.dataset.clientId?.trim() ?? script?.dataset.apiKey?.trim();
+  if (clientId) {
+    getOrCreateEmbeddedAppRuntime({
+      clientId,
+      namespace: script?.dataset.namespace,
+      readyEventType: script?.dataset.readyEventType,
+      requestTimeoutMs: parseTimeout(script?.dataset.requestTimeoutMs),
+      targetOrigin: script?.dataset.targetOrigin
+    });
+  }
+}
+function parseTimeout(value) {
+  if (!value) {
+    return void 0;
+  }
+  const timeout = Number(value);
+  return Number.isFinite(timeout) ? timeout : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ThorAppBridgeBrowser
+});
+//# sourceMappingURL=browser.cjs.map