@phpsandbox/sdk 0.3.1 → 0.3.3

package/dist/browser/phpsandbox-sdk.iife.js

@@ -44,9 +44,11 @@ var PHPSandbox = (() => {
     PublicationRun: () => PublicationRun,
     RemoteError: () => RemoteError,
     TransportError: () => TransportError,
+    createPublicationStreamResponse: () => createPublicationStreamResponse,
     laravelCloudSetupForRepublish: () => laravelCloudSetupForRepublish,
     notebookBuiltinServices: () => notebookBuiltinServices,
-    notebookKnownServices: () => notebookKnownServices
+    notebookKnownServices: () => notebookKnownServices,
+    readPublicationStream: () => readPublicationStream
   });
 
   // src/errors/index.ts
@@ -14832,6 +14834,140 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     return PublishStreamEventSchema.parse({ type, ...event.data });
   });
 
+  // src/publication/stream.ts
+  async function* readPublicationStream(input, options = {}) {
+    if (input instanceof Response && (!input.ok || !input.body)) {
+      await input.body?.cancel().catch(() => void 0);
+      throw new PHPSandboxError(`Publishing stream is unavailable (HTTP ${input.status}).`);
+    }
+    const stream = input instanceof Response ? input.body : input;
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let eventName = "message";
+    let data = [];
+    let ended = false;
+    let receivedResult = false;
+    function dispatch() {
+      const name = eventName;
+      const lines = data;
+      eventName = "message";
+      data = [];
+      if (!lines.length || !PublishStreamSseEventNameSchema.safeParse(name).success) return null;
+      const raw = lines.join("\n");
+      let payload;
+      try {
+        payload = JSON.parse(raw);
+      } catch {
+        payload = raw;
+      }
+      const event = PublishStreamSseEventSchema.parse({ event: name, data: payload });
+      if (event.type === "result") receivedResult = true;
+      return event;
+    }
+    function line(value) {
+      if (value === "") return dispatch();
+      if (value.startsWith(":")) return null;
+      const colon = value.indexOf(":");
+      const field = colon < 0 ? value : value.slice(0, colon);
+      let content = colon < 0 ? "" : value.slice(colon + 1);
+      if (content.startsWith(" ")) content = content.slice(1);
+      if (field === "event") eventName = content;
+      if (field === "data") data.push(content);
+      return null;
+    }
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        buffer += done ? decoder.decode() : decoder.decode(value, { stream: true });
+        let match;
+        while (match = /\r\n|\r|\n/.exec(buffer)) {
+          if (!done && match[0] === "\r" && match.index === buffer.length - 1) break;
+          const event = line(buffer.slice(0, match.index));
+          buffer = buffer.slice(match.index + match[0].length);
+          if (event) yield event;
+        }
+        if (done) {
+          ended = true;
+          if (buffer) {
+            const event2 = line(buffer);
+            if (event2) yield event2;
+          }
+          const event = dispatch();
+          if (event) yield event;
+          if (options.requireResult !== false && !receivedResult) {
+            throw new PHPSandboxError("Publish stream ended without result");
+          }
+          return;
+        }
+      }
+    } finally {
+      if (!ended) await reader.cancel().catch(() => void 0);
+      reader.releaseLock();
+    }
+  }
+  function createPublicationStreamResponse(stream, options = {}) {
+    const reader = stream.getReader();
+    let disposed = false;
+    let finished = false;
+    let cancellation;
+    let abort;
+    async function dispose() {
+      if (disposed) return;
+      disposed = true;
+      options.signal?.removeEventListener("abort", abort);
+      reader.releaseLock();
+      await options.onDispose?.();
+    }
+    function cancel(reason) {
+      return cancellation ?? (cancellation = (async () => {
+        finished = true;
+        try {
+          await reader.cancel(reason);
+        } finally {
+          await dispose();
+        }
+      })());
+    }
+    return new Response(new ReadableStream({
+      start(controller) {
+        abort = () => {
+          controller.error(options.signal.reason);
+          void cancel(options.signal.reason).catch(() => void 0);
+        };
+        if (options.signal?.aborted) abort();
+        else options.signal?.addEventListener("abort", abort, { once: true });
+      },
+      async pull(controller) {
+        try {
+          const { done, value } = await reader.read();
+          if (finished) return;
+          if (done) {
+            finished = true;
+            await dispose();
+            controller.close();
+          } else {
+            controller.enqueue(value);
+          }
+        } catch (error51) {
+          if (finished && cancellation) return;
+          try {
+            await cancel(error51);
+          } finally {
+            controller.error(error51);
+          }
+        }
+      },
+      cancel
+    }, { highWaterMark: 0 }), {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache, no-transform",
+        "X-Accel-Buffering": "no"
+      }
+    });
+  }
+
   // src/publication/run.ts
   var PublicationRun = class {
     constructor(initial, client) {
@@ -14919,7 +15055,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     async consumeStream(eventStreamUrl) {
       try {
         const stream = await this.client.sse(eventStreamUrl, this.streamAbort.signal);
-        for await (const event of readPublishStreamEvents(stream)) {
+        for await (const event of readPublicationStream(stream)) {
           this.publish(event);
           if (event.type === "result") {
             const { type: _, ...result } = event;
@@ -15020,78 +15156,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       });
     }
   };
-  async function* readPublishStreamEvents(stream) {
-    const reader = parseSSEStream(stream).getReader();
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          return;
-        }
-        const event = parsePublishStreamEvent(value);
-        if (event) {
-          yield event;
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  function parsePublishStreamEvent(event) {
-    if (!PublishStreamSseEventNameSchema.safeParse(event.event).success) {
-      return null;
-    }
-    return PublishStreamSseEventSchema.parse(event);
-  }
-  function parseSSEStream(input) {
-    const decoder = new TextDecoder();
-    let buffer = "";
-    return input.pipeThrough(
-      new TransformStream({
-        transform(chunk, controller) {
-          buffer += decoder.decode(chunk, { stream: true });
-          const blocks = buffer.split("\n\n");
-          buffer = blocks.pop() ?? "";
-          for (const block of blocks) {
-            const event = parseSSEBlock(block);
-            if (event) {
-              controller.enqueue(event);
-            }
-          }
-        },
-        flush(controller) {
-          buffer += decoder.decode();
-          if (buffer.trim() !== "") {
-            const event = parseSSEBlock(buffer);
-            if (event) {
-              controller.enqueue(event);
-            }
-          }
-        }
-      })
-    );
-  }
-  function parseSSEBlock(block) {
-    let eventType = "message";
-    let data = "";
-    for (const line of block.split("\n")) {
-      if (line.startsWith("event: ")) {
-        eventType = line.slice(7).trim();
-      } else if (line.startsWith("data: ")) {
-        data += line.slice(6);
-      } else if (line.startsWith("data:")) {
-        data += line.slice(5);
-      }
-    }
-    if (data === "") {
-      return null;
-    }
-    try {
-      return { event: eventType, data: JSON.parse(data) };
-    } catch {
-      return { event: eventType, data };
-    }
-  }
 
   // src/publication/resources.ts
   var PublicationResources = class {
@@ -15183,6 +15247,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     follow() {
       return new PublicationRun(this, this.client).start();
     }
+    /** Open the original publishing SSE bytes for an authenticated, transparent proxy. */
+    async stream(signal) {
+      if (!this.data.eventStreamUrl) {
+        throw new PHPSandboxError(`Publication ${this.data.id} has no eventStreamUrl for SSE streaming`);
+      }
+      return this.client.sse(this.data.eventStreamUrl, signal);
+    }
     async destroy(options = {}) {
       const query = options.deleteResources ? "?deleteResources=1" : "";
       await this.client.delete(`/publications/${encodeURIComponent(this.data.id)}${query}`);
@@ -19650,6 +19721,16 @@ ${JSON.stringify(metadata, null, 2)}` : "";
     async installation() {
       return (await this.client.get(`/servers/${encodeURIComponent(this.data.id)}/installation`)).data;
     }
+    async members(options = {}) {
+      const query = options.page === void 0 ? "" : `?${new URLSearchParams({ page: String(options.page) }).toString()}`;
+      return this.client.get(`/servers/${encodeURIComponent(this.data.id)}/members${query}`);
+    }
+    async share(email3) {
+      return (await this.client.post(`/servers/${encodeURIComponent(this.data.id)}/members`, { email: email3 })).data;
+    }
+    async revokeAccess(memberId) {
+      await this.client.delete(`/servers/${encodeURIComponent(this.data.id)}/members/${encodeURIComponent(String(memberId))}`);
+    }
     refresh() {
       return this.client.servers.get(this.data.id);
     }