@jtl-software/cloud-apps-core 0.0.0-dev.fd5f03e → 0.0.0-dev.fdea84c

package/dist/AppBridge.d.ts

@@ -1,7 +1,17 @@
 import { AppBridgeEventCapability, AppBridgeMethodCapability } from './capabilities';
 import { AppBridgeInfrastructure, AppBridgeMessagePort } from './core';
+/** The app-scoped panel token the host mints and pushes; the payload of `getAppToken`/`appTokenChanged`. */
+export type AppToken = {
+    accessToken: string;
+    refreshToken?: string;
+    expiresIn: number;
+};
 export default class AppBridge extends AppBridgeInfrastructure {
     readonly method: AppBridgeMethodCapability;
     readonly event: AppBridgeEventCapability;
+    private cachedAppToken;
+    private readonly disposers;
     constructor(appBridgeMessagePort: AppBridgeMessagePort);
+    /** Removes the panel-token cache subscription and wake listeners. Call when tearing the bridge down. */
+    dispose(): void;
 }

package/dist/AppBridge.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/capabilities/method/AppBridgeMethodCapability.d.ts

@@ -1,7 +1,15 @@
 import { Disposer, AppBridgeCapability, AppBridgeMessagePort } from '../../core';
 export default class AppBridgeMethodCapability extends AppBridgeCapability<'method'> {
     private readonly _exposedMethods;
+    private readonly _localResponders;
     constructor(appBridgeMessagePort: AppBridgeMessagePort);
+    /**
+     * Answer a `call(methodName, ...)` locally instead of sending it to the other side, when the
+     * handler returns a defined value; a returned `undefined` falls through to the remote method.
+     * Lets the bridge serve a locally cached result (e.g. a pushed panel token) without a round-trip,
+     * transparently to the caller. Returns a disposer that removes the responder.
+     */
+    respondLocally<TMethod>(methodName: string, handler: TMethod): Disposer;
     expose<TMethod>(methodName: string, method: TMethod): Disposer;
     removeExposedMethod(methodName: string): void;
     isExposed(methodName: string): boolean;

package/dist/main.js

@@ -3740,8 +3740,21 @@ class AppBridgeMethodCapability extends AppBridgeCapability {
   constructor(appBridgeMessagePort) {
     super(appBridgeMessagePort);
     __publicField(this, "_exposedMethods", {});
+    __publicField(this, "_localResponders", {});
     this.registerMessageHandler("method:call", this.handleMethodCall);
   }
+  /**
+   * Answer a `call(methodName, ...)` locally instead of sending it to the other side, when the
+   * handler returns a defined value; a returned `undefined` falls through to the remote method.
+   * Lets the bridge serve a locally cached result (e.g. a pushed panel token) without a round-trip,
+   * transparently to the caller. Returns a disposer that removes the responder.
+   */
+  respondLocally(methodName, handler) {
+    this._localResponders[methodName] = handler;
+    return () => {
+      delete this._localResponders[methodName];
+    };
+  }
   expose(methodName, method) {
     this._exposedMethods[methodName] = method;
     return () => {
@@ -3755,6 +3768,16 @@ class AppBridgeMethodCapability extends AppBridgeCapability {
     return !!this._exposedMethods[methodName];
   }
   async call(methodName, ...args) {
+    const localResponder = this._localResponders[methodName];
+    if (localResponder) {
+      let local = localResponder(...args);
+      if (local instanceof Promise) {
+        local = await local;
+      }
+      if (local !== void 0) {
+        return local;
+      }
+    }
     return this.sendMessage("method:call", { methodName, args });
   }
   async handleMethodCall({ body }) {
@@ -3770,13 +3793,49 @@ class AppBridgeMethodCapability extends AppBridgeCapability {
     return result;
   }
 }
+const REFRESH_BUFFER_MS = 6e4;
 class AppBridge extends AppBridgeInfrastructure {
   constructor(appBridgeMessagePort) {
     super(appBridgeMessagePort);
     __publicField(this, "method");
     __publicField(this, "event");
+    __publicField(this, "cachedAppToken");
+    __publicField(this, "disposers", []);
     this.method = this.registerCapability(AppBridgeMethodCapability);
     this.event = this.registerCapability(AppBridgeEventCapability);
+    this.disposers.push(
+      this.event.subscribe("appTokenChanged", (token) => {
+        this.cachedAppToken = { token, expiresAtMs: Date.now() + token.expiresIn * 1e3 };
+      })
+    );
+    this.disposers.push(
+      this.method.respondLocally("getAppToken", () => {
+        if (this.cachedAppToken && this.cachedAppToken.expiresAtMs - Date.now() > REFRESH_BUFFER_MS) {
+          return this.cachedAppToken.token;
+        }
+        return void 0;
+      })
+    );
+    const onWake = () => {
+      if (!document.hidden) {
+        void this.method.call("getAppToken").catch(() => {
+        });
+      }
+    };
+    if (typeof window !== "undefined" && typeof document !== "undefined") {
+      document.addEventListener("visibilitychange", onWake);
+      window.addEventListener("focus", onWake);
+      window.addEventListener("online", onWake);
+      this.disposers.push(() => {
+        document.removeEventListener("visibilitychange", onWake);
+        window.removeEventListener("focus", onWake);
+        window.removeEventListener("online", onWake);
+      });
+    }
+  }
+  /** Removes the panel-token cache subscription and wake listeners. Call when tearing the bridge down. */
+  dispose() {
+    this.disposers.splice(0).forEach((dispose) => dispose());
   }
 }
 function createAppBridge() {