@verentis/sdk 0.2.3 → 0.2.4

package/README.md

@@ -57,6 +57,30 @@ Release the 0.2 SDK before deploying apps that require `^0.2.0`, together with t
 Local sibling-repository development can link the built SDK; published applications must resolve
 the released SDK from npm.
 
+### WOPI editor launch
+
+Signed WOPI applications use `Bridge.requestWopiLaunch()` after `waitForInit()`.
+The authenticated workspace parent chooses the installed editor, document,
+branch and action; the child cannot request arbitrary document identities.
+The returned token is scoped to WOPI and is not a normal workspace API token.
+Submit it using a form POST to the validated discovery action, never a URL.
+
+`requestWopiSave(generation)`, `getWopiStatus()` and `closeWopiSession()` use the
+same exact-parent, origin/session/request-correlated bridge. A matching durable
+save receipt—not a CODE postMessage alone—is required before clearing dirty state.
+When status reports `continuationAvailable`, `requestWopiContinuation()` asks
+the parent to bind the target of a completed server-owned Save As operation.
+It accepts no document or acquisition IDs. Its `WopiContinuation` result contains
+only document metadata and the persisted target `accessTokenTtl`, not a token,
+action URL or private control credential. The parent obtains the exact existing
+control IDs from authenticated `/derived`; it does not reconstruct a launch,
+including after signing-key rotation. Keep the initial launch/form separate from
+active document metadata, retain CODE's iframe and existing token, and preserve
+unverified edits until a matching target save receipt arrives.
+These methods do not replace `requestBackendCredential()` or ordinary OAuth
+authentication for apps that need workspace APIs. WOPI-only packages need no
+per-editor OAuth client secret.
+
 ### Standalone mode (local development)
 
 ```ts

package/dist/index.cjs

@@ -809,6 +809,7 @@ var Bridge = class {
   actions = /* @__PURE__ */ new Map();
   requests = /* @__PURE__ */ new Set();
   backendRequests = /* @__PURE__ */ new Map();
+  wopiRequests = /* @__PURE__ */ new Map();
   /** Post `verentis:ready` to the host to start the handshake */
   sendReady(capabilities) {
     console.info("[Verentis SDK] Sending verentis:ready to host");
@@ -817,7 +818,7 @@ var Bridge = class {
       version: 1,
       capabilities
     };
-    window.parent.postMessage(message, "*");
+    window.parent.postMessage(message, this.expectedHostOrigin ?? "*");
   }
   /** Wait for the host to send `verentis:init` with context and token */
   waitForInit() {
@@ -892,6 +893,53 @@ var Bridge = class {
       }
     });
   }
+  /** The trusted parent selects the approved installation, document and action. */
+  requestWopiLaunch() {
+    return this.requestWopi("launch");
+  }
+  /** Recover only the target selected by a completed server-owned derived operation. */
+  requestWopiContinuation() {
+    return this.requestWopi("continue");
+  }
+  getWopiStatus() {
+    return this.requestWopi("status");
+  }
+  requestWopiSave(generation) {
+    if (!Number.isSafeInteger(generation) || generation < 0)
+      return Promise.reject(new Error("Invalid edit generation."));
+    return this.requestWopi("save", generation);
+  }
+  closeWopiSession() {
+    return this.requestWopi("close");
+  }
+  requestWopi(operation, generation) {
+    if (this._destroyed || !this.sessionId || !this._hostOrigin)
+      return Promise.reject(new Error("An initialized workspace host is required."));
+    if (this.wopiRequests.size >= 4)
+      return Promise.reject(new Error("Too many collaboration requests."));
+    const requestId = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.wopiRequests.delete(requestId);
+        reject(new Error("Collaboration authorization timed out."));
+      }, 3e4);
+      this.wopiRequests.set(requestId, { resolve, reject, timer });
+      try {
+        this.postToHost({
+          type: "verentis:wopi:request",
+          version: 1,
+          requestId,
+          sessionId: this.sessionId,
+          operation,
+          ...generation === void 0 ? {} : { generation }
+        });
+      } catch {
+        clearTimeout(timer);
+        this.wopiRequests.delete(requestId);
+        reject(new Error("The workspace host is unavailable."));
+      }
+    });
+  }
   registerAction(descriptor, handler) {
     if (!this.sessionId || this._destroyed) throw new Error("Header actions require an initialized workspace host.");
     if (!isHeaderAction(descriptor)) throw new Error("Invalid header action.");
@@ -979,6 +1027,11 @@ var Bridge = class {
       pending.reject(new Error("Bridge has been destroyed."));
     }
     this.backendRequests.clear();
+    for (const pending of this.wopiRequests.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Bridge has been destroyed."));
+    }
+    this.wopiRequests.clear();
     if (typeof window !== "undefined") {
       window.removeEventListener("message", this._messageHandler);
     }
@@ -1016,6 +1069,17 @@ var Bridge = class {
       else pending.resolve(value);
       return;
     }
+    if (data.type === "verentis:wopi:response") {
+      if (!this._hostOrigin || data.sessionId !== this.sessionId) return;
+      const pending = this.wopiRequests.get(data.requestId);
+      if (!pending) return;
+      clearTimeout(pending.timer);
+      this.wopiRequests.delete(data.requestId);
+      if (data.error || !Object.hasOwn(data, "result"))
+        pending.reject(new Error("Collaboration authorization is unavailable."));
+      else pending.resolve(data.result);
+      return;
+    }
     if (data.type === "verentis:action:invoke") {
       void this.invokeAction(data);
       return;