@versori/run 0.0.1-alpha.1 → 0.0.1-alpha.3

package/esm/deps/jsr.io/@oak/commons/1.0.0/range.js

@@ -0,0 +1,503 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _MultiPartByteRangesStream_instances, _MultiPartByteRangesStream_boundary, _MultiPartByteRangesStream_contentLength, _MultiPartByteRangesStream_postscript, _MultiPartByteRangesStream_previous, _MultiPartByteRangesStream_ranges, _MultiPartByteRangesStream_seen, _MultiPartByteRangesStream_source, _MultiPartByteRangesStream_type, _MultiPartByteRangesStream_readRange;
+/**
+ * A module which provides capabilities to deal with handling HTTP
+ * [range requests](https://developer.mozilla.org/en-US/docs/Web/HTTP/Range_requests).
+ *
+ * The {@linkcode range} function can be used to determine if a range can be
+ * satisfied for a requested resource. The {@linkcode responseRange} can be used
+ * to fulfill range requests.
+ *
+ * The module provides specific support for {@linkcode Deno.FsFile} to provide
+ * an efficient way of send the response to the range request without having to
+ * read the whole file into memory by using the `.seek()` API.
+ *
+ * There are also some lower level constructs which can be used for advanced
+ * use cases.
+ *
+ *   - {@linkcode MultiPartByteRangesStream} is a readable stream which
+ *     generates a body that converts the source to a multipart byte range
+ *     document.
+ *   - {@linkcode RangeByteTransformStream} is a transform stream which will
+ *     only stream the bytes indicated by the range.
+ *   - {@linkcode contentRange} sets the headers that are appropriate when
+ *     sending a range content response.
+ *   - {@linkcode multiPartByteRanges} sets the headers that are appropriate
+ *     when sending a multi part byte range content response.
+ *   - {@linkcode asLimitedReadableStream} leverages the `.seek()` APIs with a
+ *     {@linkcode Deno.FsFile} to provide a more performant and memory efficient
+ *     way to stream just a range of bytes form a file.
+ *
+ * @example A simple static webserver supporting range requests
+ *
+ * ```ts
+ * import { range, responseRange } from "jsr:@oak/commons/range";
+ * import { typeByExtension } from "jsr:@std/media-types/type-by-extension";
+ * import { extname } from "jsr:@std/path/extname";
+ *
+ * Deno.serve(async (req) => {
+ *   const url = new URL(req.url);
+ *   const file = await Deno.open(`./static${url.pathname}`);
+ *   const fileInfo = await file.stat();
+ *   const headers = { "accept-ranges": "bytes", "content-type": type };
+ *   if (req.method === "HEAD") {
+ *     return new Response(null, {
+ *       headers: {
+ *         ...headers,
+ *         "content-length": String(fileInfo.size),
+ *       },
+ *     });
+ *   }
+ *   if (req.method === "GET") {
+ *     const result = await range(req, fileInfo);
+ *     if (result.ok) {
+ *       if (result.ranges) {
+ *         return responseRange(file, fileInfo.size, result.ranges, {
+ *           headers,
+ *         }, { type });
+ *       } else {
+ *         return new Response(file.readable, {
+ *           headers: {
+ *             ...headers,
+ *             "content-length": String(fileInfo.size),
+ *           },
+ *         });
+ *       }
+ *     } else {
+ *       return new Response(null, {
+ *         status: 416,
+ *         statusText: "Range Not Satisfiable",
+ *         headers,
+ *       });
+ *     }
+ *   }
+ *   return new Response(null, { status: 405, statusText: "Method Not Allowed" });
+ * });
+ * ```
+ *
+ * @module
+ */
+import * as dntShim from "../../../../../_dnt.shims.js";
+import { assert } from "../../../@std/assert/1.0.11/assert.js";
+import { concat } from "../../../@std/bytes/1.0.5/concat.js";
+import { eTag } from "../../../@std/http/1.0.13/etag.js";
+const DEFAULT_CHUNK_SIZE = 524_288;
+const ETAG_RE = /(?:W\/)?"[ !#-\x7E\x80-\xFF]+"/;
+const encoder = new TextEncoder();
+function isDenoFsFile(value) {
+    if (!value || value === null || !("Deno" in dntShim.dntGlobalThis) || !dntShim.Deno.FsFile) {
+        return false;
+    }
+    return value instanceof dntShim.Deno.FsFile;
+}
+function isFileInfo(value) {
+    return !!(typeof value === "object" && value && "mtime" in value);
+}
+function isModified(value, mtime) {
+    const a = new Date(value).getTime();
+    let b = mtime.getTime();
+    // adjust to the precision of HTTP UTC time
+    b -= b % 1000;
+    return a < b;
+}
+async function readRange(file, { start, end }) {
+    const parts = [];
+    let read = 0;
+    const length = end - start + 1;
+    const pos = await file.seek(start, dntShim.Deno.SeekMode.Start);
+    if (pos !== start) {
+        throw new RangeError("Could not seek to range start.");
+    }
+    while (read < length) {
+        const chunk = new Uint8Array(length - read);
+        const count = await file.read(chunk);
+        if (count === null) {
+            throw new RangeError("Could not read to range end.");
+        }
+        parts.push(chunk);
+        read += count;
+    }
+    return parts.length > 1 ? concat(parts) : parts[0];
+}
+/**
+ * A readable stream that will stream a body formatted as a
+ * `multipart/byteranges` document. The `source` needs to be a
+ * {@linkcode Deno.FsFile}, {@linkcode ReadableStream}, {@linkcode Blob},
+ * {@linkcode BufferSource}, or a `string`.
+ */
+export class MultiPartByteRangesStream extends ReadableStream {
+    /**
+     * The boundary being used when segmenting different parts of the body
+     * response. This should be reflected in the `Content-Type` header when
+     * being sent to a client.
+     */
+    get boundary() {
+        return __classPrivateFieldGet(this, _MultiPartByteRangesStream_boundary, "f");
+    }
+    /**
+     * The length of the content being supplied by the stream. This should be
+     * reflected in the `Content-Length` header when being sent to a client.
+     */
+    get contentLength() {
+        return __classPrivateFieldGet(this, _MultiPartByteRangesStream_contentLength, "f");
+    }
+    constructor(source, ranges, size, options = {}) {
+        const { autoClose = true, boundary = "OAK-COMMONS-BOUNDARY", type, } = options;
+        super({
+            pull: async (controller) => {
+                const range = __classPrivateFieldGet(this, _MultiPartByteRangesStream_ranges, "f").shift();
+                if (!range) {
+                    controller.enqueue(__classPrivateFieldGet(this, _MultiPartByteRangesStream_postscript, "f"));
+                    controller.close();
+                    if (autoClose && isDenoFsFile(__classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f"))) {
+                        __classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f").close();
+                    }
+                    if (__classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f") instanceof ReadableStreamDefaultReader) {
+                        __classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f").releaseLock();
+                    }
+                    return;
+                }
+                const bytes = await __classPrivateFieldGet(this, _MultiPartByteRangesStream_instances, "m", _MultiPartByteRangesStream_readRange).call(this, range);
+                const preamble = encoder.encode(`\r\n--${boundary}\r\nContent-Type: ${__classPrivateFieldGet(this, _MultiPartByteRangesStream_type, "f")}\r\nContent-Range: ${range.start}-${range.end}/${size}\r\n\r\n`);
+                controller.enqueue(concat([preamble, bytes]));
+            },
+        });
+        _MultiPartByteRangesStream_instances.add(this);
+        _MultiPartByteRangesStream_boundary.set(this, void 0);
+        _MultiPartByteRangesStream_contentLength.set(this, void 0);
+        _MultiPartByteRangesStream_postscript.set(this, void 0);
+        _MultiPartByteRangesStream_previous.set(this, void 0);
+        _MultiPartByteRangesStream_ranges.set(this, void 0);
+        _MultiPartByteRangesStream_seen.set(this, 0);
+        _MultiPartByteRangesStream_source.set(this, void 0);
+        _MultiPartByteRangesStream_type.set(this, void 0);
+        __classPrivateFieldSet(this, _MultiPartByteRangesStream_boundary, boundary, "f");
+        __classPrivateFieldSet(this, _MultiPartByteRangesStream_ranges, [...ranges], "f");
+        __classPrivateFieldGet(this, _MultiPartByteRangesStream_ranges, "f").sort(({ start: a }, { start: b }) => a - b);
+        if (ArrayBuffer.isView(source)) {
+            __classPrivateFieldSet(this, _MultiPartByteRangesStream_source, source.buffer, "f");
+        }
+        else if (typeof source === "string") {
+            __classPrivateFieldSet(this, _MultiPartByteRangesStream_source, encoder.encode(source).buffer, "f");
+        }
+        else if (source instanceof ReadableStream) {
+            __classPrivateFieldSet(this, _MultiPartByteRangesStream_source, source.getReader(), "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _MultiPartByteRangesStream_source, source, "f");
+        }
+        __classPrivateFieldSet(this, _MultiPartByteRangesStream_type, type || (source instanceof Blob && source.type) ||
+            "application/octet-stream", "f");
+        __classPrivateFieldSet(this, _MultiPartByteRangesStream_postscript, encoder.encode(`\r\n--${boundary}--\r\n`), "f");
+        __classPrivateFieldSet(this, _MultiPartByteRangesStream_contentLength, ranges.reduce((prev, { start, end }) => prev +
+            encoder.encode(`\r\n--${boundary}\r\nContent-Type: ${__classPrivateFieldGet(this, _MultiPartByteRangesStream_type, "f")}\r\nContent-Range: ${start}-${end}/${size}\r\n\r\n`).byteLength + (end - start) + 1, __classPrivateFieldGet(this, _MultiPartByteRangesStream_postscript, "f").byteLength), "f");
+    }
+}
+_MultiPartByteRangesStream_boundary = new WeakMap(), _MultiPartByteRangesStream_contentLength = new WeakMap(), _MultiPartByteRangesStream_postscript = new WeakMap(), _MultiPartByteRangesStream_previous = new WeakMap(), _MultiPartByteRangesStream_ranges = new WeakMap(), _MultiPartByteRangesStream_seen = new WeakMap(), _MultiPartByteRangesStream_source = new WeakMap(), _MultiPartByteRangesStream_type = new WeakMap(), _MultiPartByteRangesStream_instances = new WeakSet(), _MultiPartByteRangesStream_readRange = async function _MultiPartByteRangesStream_readRange({ start, end }) {
+    if (isDenoFsFile(__classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f"))) {
+        return readRange(__classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f"), { start, end });
+    }
+    if (__classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f") instanceof Blob) {
+        return new Uint8Array(await __classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f").slice(start, end + 1).arrayBuffer());
+    }
+    if (__classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f") instanceof ArrayBuffer) {
+        return new Uint8Array(__classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f").slice(start, end + 1));
+    }
+    const length = end - start;
+    let read = 0;
+    let result;
+    const processChunk = (chunk) => {
+        if (__classPrivateFieldGet(this, _MultiPartByteRangesStream_seen, "f") + chunk.byteLength >= start) {
+            if (__classPrivateFieldGet(this, _MultiPartByteRangesStream_seen, "f") < start) {
+                chunk = chunk.slice(start - __classPrivateFieldGet(this, _MultiPartByteRangesStream_seen, "f"));
+                __classPrivateFieldSet(this, _MultiPartByteRangesStream_seen, start, "f");
+            }
+            if (read + chunk.byteLength > length + 1) {
+                __classPrivateFieldSet(this, _MultiPartByteRangesStream_previous, chunk.slice(length - read + 1), "f");
+                chunk = chunk.slice(0, length - read + 1);
+            }
+            read += chunk.byteLength;
+            __classPrivateFieldSet(this, _MultiPartByteRangesStream_seen, __classPrivateFieldGet(this, _MultiPartByteRangesStream_seen, "f") + chunk.byteLength, "f");
+            return chunk;
+        }
+        __classPrivateFieldSet(this, _MultiPartByteRangesStream_seen, __classPrivateFieldGet(this, _MultiPartByteRangesStream_seen, "f") + chunk.byteLength, "f");
+    };
+    if (__classPrivateFieldGet(this, _MultiPartByteRangesStream_previous, "f")) {
+        const chunk = __classPrivateFieldGet(this, _MultiPartByteRangesStream_previous, "f");
+        __classPrivateFieldSet(this, _MultiPartByteRangesStream_previous, undefined, "f");
+        const res = processChunk(chunk);
+        if (res) {
+            result = res;
+        }
+    }
+    while (read < length) {
+        const { done, value: chunk } = await __classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f").read();
+        if (chunk) {
+            const res = processChunk(chunk);
+            if (res) {
+                result = result ? concat([result, res]) : res;
+            }
+        }
+        if (done) {
+            throw new RangeError("Unable to read range.");
+        }
+    }
+    assert(result);
+    return result;
+};
+/**
+ * A {@linkcode TransformStream} which will only provide the range of bytes from
+ * the source stream.
+ */
+export class RangeByteTransformStream extends TransformStream {
+    constructor(range) {
+        const { start, end } = range;
+        const length = end - start;
+        let seen = 0;
+        let read = 0;
+        super({
+            transform(chunk, controller) {
+                if (seen + chunk.byteLength >= start) {
+                    if (seen < start) {
+                        // start is part way through chunk
+                        chunk = chunk.slice(start - seen);
+                        seen = start;
+                    }
+                    if (read + chunk.byteLength > length + 1) {
+                        // chunk extends past end
+                        chunk = chunk.slice(0, length - read + 1);
+                    }
+                    read += chunk.byteLength;
+                    seen += chunk.byteLength;
+                    controller.enqueue(chunk);
+                    if (read >= length) {
+                        controller.terminate();
+                    }
+                }
+                else {
+                    // skip chunk
+                    seen += chunk.byteLength;
+                }
+            },
+        });
+    }
+}
+/**
+ * Set {@linkcode Headers} related to returning a content range to the client.
+ *
+ * This will set the `Accept-Ranges`, `Content-Range` and `Content-Length` as
+ * appropriate. If the headers does not contain a `Content-Type` header, and one
+ * is supplied, it will be added.
+ */
+export function contentRange(headers, range, size, type) {
+    const { start, end } = range;
+    headers.set("accept-ranges", "bytes");
+    headers.set("content-range", `bytes ${start}-${end}/${size}`);
+    headers.set("content-length", String(end - start + 1));
+    if (type && !headers.has("content-type")) {
+        headers.set("content-type", type);
+    }
+}
+/**
+ * Set {@linkcode Headers} related to returning a multipart byte range response.
+ *
+ * This will set the `Content-Type` and `Content-Length` headers as appropriate.
+ */
+export function multiPartByteRanges(headers, init) {
+    const { contentLength, boundary } = init;
+    headers.set("content-type", `multipart/byteranges; boundary=${boundary}`);
+    headers.set("content-length", String(contentLength));
+}
+/**
+ * Converts a {@linkcode DenoFile} and a {@linkcode ByteRange} into a byte
+ * {@linkcode ReadableStream} which will provide just the range of bytes.
+ *
+ * When the stream is finished being ready, the file will be closed. Changing
+ * the option to `autoClose` to `false` will disable this behavior.
+ */
+export function asLimitedReadableStream(fsFile, range, options = {}) {
+    const { start, end } = range;
+    const { autoClose = true, chunkSize = DEFAULT_CHUNK_SIZE } = options;
+    let read = 0;
+    const length = end - start + 1;
+    return new ReadableStream({
+        start(controller) {
+            const pos = fsFile.seekSync(start, dntShim.Deno.SeekMode.Start);
+            if (pos !== start) {
+                controller.error(new RangeError("Could not seek to range start."));
+            }
+        },
+        async pull(controller) {
+            const chunk = new Uint8Array(Math.min(length - read, chunkSize));
+            const count = await fsFile.read(chunk);
+            if (count == null) {
+                controller.error(new RangeError("Could not read to range end."));
+                return;
+            }
+            controller.enqueue(chunk);
+            read += count;
+            if (read >= length) {
+                controller.close();
+                if (autoClose) {
+                    fsFile.close();
+                }
+            }
+        },
+        autoAllocateChunkSize: chunkSize,
+        type: "bytes",
+    });
+}
+export async function range(request, entity, fileInfo) {
+    const ifRange = request.headers.get("if-range");
+    if (ifRange) {
+        const matches = ETAG_RE.exec(ifRange);
+        if (matches) {
+            const [match] = matches;
+            // this indicates that it would be a weak tag, and we cannot compare on
+            // weak tags, the full entity should be returned
+            if (!fileInfo || match.startsWith("W")) {
+                return { ok: true, ranges: null };
+            }
+            // @ts-ignore the types for eTag are not correct
+            if (match !== await eTag(entity)) {
+                return { ok: true, ranges: null };
+            }
+        }
+        else {
+            assert(fileInfo || isFileInfo(entity));
+            const { mtime } = fileInfo ?? entity;
+            if (!mtime || isModified(ifRange, mtime)) {
+                return { ok: true, ranges: null };
+            }
+        }
+    }
+    const value = request.headers.get("range");
+    if (!value) {
+        return { ok: true, ranges: null };
+    }
+    const [unit, rangesStr] = value.split("=");
+    if (unit !== "bytes") {
+        return { ok: false, ranges: null };
+    }
+    const ranges = [];
+    for (const range of rangesStr.split(/\s*,\s+/)) {
+        const item = range.split("-");
+        if (item.length !== 2) {
+            return { ok: false, ranges: null };
+        }
+        const { size } = fileInfo ?? entity;
+        const [startStr, endStr] = item;
+        let start;
+        let end;
+        try {
+            if (startStr === "") {
+                start = size - parseInt(endStr, 10) - 1;
+                end = size - 1;
+            }
+            else if (endStr === "") {
+                start = parseInt(startStr, 10);
+                end = size - 1;
+            }
+            else {
+                start = parseInt(startStr, 10);
+                end = parseInt(endStr, 10);
+            }
+        }
+        catch {
+            return { ok: false, ranges: null };
+        }
+        if (start < 0 || start >= size || end < 0 || end >= size || start > end) {
+            return { ok: false, ranges: null };
+        }
+        ranges.push({ start, end });
+    }
+    return { ok: true, ranges };
+}
+/**
+ * Resolves with a {@linkcode Response} with a body which is just the range of
+ * bytes supplied, along with the appropriate headers which indicate that it is
+ * the fulfillment of a range request.
+ *
+ * The `body` is a {@linkcode Response} {@linkcode BodyInit} with the addition
+ * of supporting {@linkcode Deno.FsFile} and does not accept
+ * {@linkcode FormData} or {@linkcode URLSearchParams}. When using
+ * {@linkcode Deno.FsFile} the seek capabilities in order to read ranges more
+ * efficiently.
+ *
+ * The `size` is the total number of bytes in the resource being responded to.
+ * This needs to be provided, because the full size of the resource being
+ * requested it may not be easy to determine at the time being requested.
+ *
+ * @example
+ *
+ * ```ts
+ * import { responseRange } from "jsr:@oak/commons/range";
+ *
+ * const file = await Deno.open("./movie.mp4");
+ * const { size } = await file.stat();
+ * const res = responseRange(
+ *   file,
+ *   size,
+ *   { start: 0, end: 1_048_575 },
+ *   { headers: { "content-type": "video/mp4" } },
+ * );
+ * const ab = await res.arrayBuffer();
+ * // ab will be the first 1MB of the video file
+ * ```
+ */
+export function responseRange(body, size, ranges, init = {}, options = {}) {
+    if (!ranges.length) {
+        throw new RangeError("At least one range expected.");
+    }
+    if (ranges.length === 1) {
+        const [range] = ranges;
+        let type = options.type ?? "application/octet-stream";
+        if (isDenoFsFile(body)) {
+            body = asLimitedReadableStream(body, range, options);
+        }
+        else if (body instanceof ReadableStream) {
+            body = body.pipeThrough(new RangeByteTransformStream(range));
+        }
+        else if (body instanceof Blob) {
+            type = body.type;
+            body = body.slice(range.start, range.end + 1);
+        }
+        else if (ArrayBuffer.isView(body)) {
+            body = body.buffer.slice(range.start, range.end + 1);
+        }
+        else if (body instanceof ArrayBuffer) {
+            body = body.slice(range.start, range.end + 1);
+        }
+        else if (typeof body === "string") {
+            body = encoder.encode(body).slice(range.start, range.end + 1);
+        }
+        else {
+            throw TypeError("Invalid body type.");
+        }
+        const res = new Response(body, {
+            ...init,
+            status: 206,
+            statusText: "Partial Content",
+        });
+        contentRange(res.headers, range, size, type);
+        return res;
+    }
+    const stream = new MultiPartByteRangesStream(body, ranges, size, options);
+    const res = new Response(stream, {
+        ...init,
+        status: 206,
+        statusText: "Partial Content",
+    });
+    multiPartByteRanges(res.headers, stream);
+    return res;
+}

package/esm/deps/jsr.io/@oak/commons/1.0.0/server_sent_event.d.ts

@@ -0,0 +1,178 @@
+/** Options which can be set when initializing a {@linkcode ServerSentEvent}. */
+export interface ServerSentEventInit extends EventInit {
+    /**
+     * Optional arbitrary data to send to the client, data this is a string will
+     * be sent unmodified, otherwise `JSON.stringify()` will be used to serialize
+     * the value.
+     */
+    data?: unknown;
+    /** An optional `id` which will be sent with the event and exposed in the
+     * client `EventSource`. */
+    id?: number;
+    /** The replacer is passed to `JSON.stringify` when converting the `data`
+     * property to a JSON string. */
+    replacer?: (string | number)[] | ((this: any, key: string, value: any) => any);
+    /** Space is passed to `JSON.stringify` when converting the `data` property
+     * to a JSON string. */
+    space?: string | number;
+}
+/**
+ * Options which can be sent when initializing a
+ * {@linkcode ServerSentEventTarget}.
+ */
+export interface ServerSentEventTargetOptions {
+    /** Keep client connections alive by sending a comment event to the client
+     * at a specified interval.  If `true`, then it polls every 30000 milliseconds
+     * (30 seconds). If set to a number, then it polls that number of
+     * milliseconds.  The feature is disabled if set to `false`.  It defaults to
+     * `false`. */
+    keepAlive?: boolean | number;
+}
+declare class CloseEvent extends Event {
+    constructor(eventInit: EventInit);
+}
+/**
+ * An event which contains information which will be sent to the remote
+ * connection and be made available in an `EventSource` as an event. A server
+ * creates new events and dispatches them on the target which will then be
+ * sent to a client.
+ *
+ * See more about Server-sent events on [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   ServerSentEvent,
+ *   ServerSentEventStreamTarget,
+ * } from "jsr:@oak/commons/server_sent_event";
+ *
+ * Deno.serve({ port: 8000 }, (request) => {
+ *   const target = new ServerSentEventStreamTarget();
+ *   const evt = new ServerSentEvent("message", {
+ *     data: { hello: "world" },
+ *     id: 1
+ *   });
+ *   target.dispatchEvent(evt);
+ *   return target.asResponse();
+ * });
+ * ```
+ */
+export declare class ServerSentEvent extends Event {
+    #private;
+    /**
+     * @param type the event type that will be available on the client. The type
+     *             of `"message"` will be handled specifically as a message
+     *             server-side event.
+     * @param eventInit initialization options for the event
+     */
+    constructor(type: string, eventInit?: ServerSentEventInit);
+    /** The data associated with the event, which will be sent to the client and
+     * be made available in the `EventSource`. */
+    get data(): string;
+    /** The optional ID associated with the event that will be sent to the client
+     * and be made available in the `EventSource`. */
+    get id(): number | undefined;
+    toString(): string;
+}
+/**
+ * The abstract interface for server sent events, which is implemented in
+ * {@linkcode ServerSentEventStreamTarget}.
+ */
+export interface ServerSentEventTarget extends EventTarget {
+    /** Is set to `true` if events cannot be sent to the remote connection.
+     * Otherwise it is set to `false`.
+     *
+     * *Note*: This flag is lazily set, and might not reflect a closed state until
+     * another event, comment or message is attempted to be processed. */
+    readonly closed: boolean;
+    /** Close the target, refusing to accept any more events. */
+    close(): Promise<void>;
+    /** Send a comment to the remote connection.  Comments are not exposed to the
+     * client `EventSource` but are used for diagnostics and helping ensure a
+     * connection is kept alive.
+     *
+     * ```ts
+     * import { ServerSentEventStreamTarget } from "jsr:@oak/commons/server_sent_event";
+     *
+     * Deno.serve({ port: 8000 }, (request) => {
+     *   const target = new ServerSentEventStreamTarget();
+     *   target.dispatchComment("this is a comment");
+     *   return target.asResponse();
+     * });
+     * ```
+     */
+    dispatchComment(comment: string): boolean;
+    /** Dispatch a message to the client.  This message will contain `data: ` only
+     * and be available on the client `EventSource` on the `onmessage` or an event
+     * listener of type `"message"`. */
+    dispatchMessage(data: unknown): boolean;
+    /** Dispatch a server sent event to the client.  The event `type` will be
+     * sent as `event: ` to the client which will be raised as a `MessageEvent`
+     * on the `EventSource` in the client.
+     *
+     * Any local event handlers will be dispatched to first, and if the event
+     * is cancelled, it will not be sent to the client.
+     *
+     * ```ts
+     * import {
+     *   ServerSentEvent,
+     *   ServerSentEventStreamTarget,
+     * } from "jsr:@oak/commons/server_sent_event";
+     *
+     * Deno.serve({ port: 8000 }, (request) => {
+     *   const target = new ServerSentEventStreamTarget();
+     *   const evt = new ServerSentEvent("ping", { data: "hello" });
+     *   target.dispatchEvent(evt);
+     *   return target.asResponse();
+     * });
+     * ```
+     */
+    dispatchEvent(event: ServerSentEvent): boolean;
+    /** Dispatch a server sent event to the client.  The event `type` will be
+     * sent as `event: ` to the client which will be raised as a `MessageEvent`
+     * on the `EventSource` in the client.
+     *
+     * Any local event handlers will be dispatched to first, and if the event
+     * is cancelled, it will not be sent to the client.
+     *
+     * ```ts
+     * import {
+     *   ServerSentEvent,
+     *   ServerSentEventStreamTarget,
+     * } from "jsr:@oak/commons/server_sent_event";
+     *
+     * Deno.serve({ port: 8000 }, (request) => {
+     *   const target = new ServerSentEventStreamTarget();
+     *   const evt = new ServerSentEvent("ping", { data: "hello" });
+     *   target.dispatchEvent(evt);
+     *   return target.asResponse();
+     * });
+     * ```
+     */
+    dispatchEvent(event: CloseEvent | ErrorEvent): boolean;
+}
+/**
+ * An implementation of {@linkcode ServerSentEventTarget} that provides a
+ * readable stream as a body of a response to establish a connection to a
+ * client.
+ */
+export declare class ServerSentEventStreamTarget extends EventTarget implements ServerSentEventTarget {
+    #private;
+    get closed(): boolean;
+    constructor({ keepAlive }?: ServerSentEventTargetOptions);
+    /** Returns a {@linkcode Response} which contains the body and headers needed
+     * to initiate a SSE connection with the client. */
+    asResponse(responseInit?: ResponseInit): Response;
+    /** Returns a tuple which contains the {@linkcode BodyInit} and
+     * {@linkcode ResponseInit} needed to create a response that will establish
+     * a SSE connection with the client. */
+    asResponseInit(responseInit?: ResponseInit): [BodyInit, ResponseInit];
+    close(): Promise<void>;
+    dispatchComment(comment: string): boolean;
+    dispatchMessage(data: any): boolean;
+    dispatchEvent(event: ServerSentEvent): boolean;
+    dispatchEvent(event: CloseEvent | ErrorEvent): boolean;
+}
+export {};
+//# sourceMappingURL=server_sent_event.d.ts.map

package/esm/deps/jsr.io/@oak/commons/1.0.0/server_sent_event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server_sent_event.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@oak/commons/1.0.0/server_sent_event.ts"],"names":[],"mappings":"AAkDA,gFAAgF;AAChF,MAAM,WAAW,mBAAoB,SAAQ,SAAS;IACpD;;;;OAIG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;+BAC2B;IAC3B,EAAE,CAAC,EAAE,MAAM,CAAC;IAEZ;oCACgC;IAChC,QAAQ,CAAC,EACL,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAEnB,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC;IAElD;2BACuB;IACvB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,4BAA4B;IAC3C;;;;kBAIc;IACd,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CAC9B;AAED,cAAM,UAAW,SAAQ,KAAK;gBAChB,SAAS,EAAE,SAAS;CAGjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,eAAgB,SAAQ,KAAK;;IAKxC;;;;;OAKG;gBACS,IAAI,EAAE,MAAM,EAAE,SAAS,GAAE,mBAAwB;IAoB7D;iDAC6C;IAC7C,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;qDACiD;IACjD,IAAI,EAAE,IAAI,MAAM,GAAG,SAAS,CAE3B;IAEQ,QAAQ,IAAI,MAAM;CAM5B;AASD;;;GAGG;AACH,MAAM,WAAW,qBAAsB,SAAQ,WAAW;IACxD;;;;yEAIqE;IACrE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAEzB,4DAA4D;IAC5D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;;;;;;;;;;;;OAaG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IAE1C;;uCAEmC;IACnC,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IAExC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,aAAa,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC;IAE/C;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC;CACxD;AAED;;;;GAIG;AACH,qBAAa,2BAA4B,SAAQ,WAC/C,YAAW,qBAAqB;;IA2BhC,IAAI,MAAM,IAAI,OAAO,CAEpB;gBAEW,EAAE,SAAiB,EAAE,GAAE,4BAAiC;IA8CpE;uDACmD;IACnD,UAAU,CAAC,YAAY,CAAC,EAAE,YAAY,GAAG,QAAQ;IAIjD;;2CAEuC;IACvC,cAAc,CAAC,YAAY,GAAE,YAAiB,GAAG,CAAC,QAAQ,EAAE,YAAY,CAAC;IASzE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAMzC,eAAe,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO;IAK1B,aAAa,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO;IAC9C,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO;CAwChE"}