typedrest 0.4.1 → 0.6.0

package/endpoints/reactive/GenericStreamingCollectionEndpoint.d.ts

@@ -0,0 +1,32 @@
+import { ElementEndpoint } from "../generic/ElementEndpoint";
+import { GenericCollectionEndpoint } from "../generic/GenericCollectionEndpoint";
+/**
+ * Endpoint for a collection of `TEntity`s observable as an append-only stream using long-polling.<br>
+ * Use {@link StreamingCollectionEndpoint} instead if you wish to use the default {@link ElementEndpoint} type.
+ * @typeParam TEntity The type of individual elements in the collection.
+ * @typeParam TElementEndpoint The type of {@link ElementEndpoint} to provide for individual `TEntity`s.
+ */
+export declare class GenericStreamingCollectionEndpoint<TEntity, TElementEndpoint extends ElementEndpoint<TEntity>> extends GenericCollectionEndpoint<TEntity, TElementEndpoint> {
+    /**
+     * The interval in milliseconds to wait between polling requests.
+     * Automatically updated whenever the server sends a {@link http!HttpHeader.RetryAfter} header.
+     */
+    pollingInterval: number;
+    /**
+     * @inheritDoc
+     */
+    protected handle(response: Response): Promise<void>;
+    /**
+     * Provides a stream of `TEntity`s, polling the server for elements appended to the collection.
+     * @param startIndex The index of the first element to return. Use a negative value to start with the last `-startIndex` elements ("tail").
+     * @param signal Used to stop polling.
+     * @throws {@link errors!AuthenticationError}: {@link http!HttpStatusCode.Unauthorized}
+     * @throws {@link errors!AuthorizationError}: {@link http!HttpStatusCode.Forbidden}
+     * @throws {@link errors!HttpError}: Other non-success status code
+     */
+    stream(startIndex?: number, signal?: AbortSignal): AsyncIterableIterator<TEntity>;
+    /**
+     * Provides a stream of `TEntity`s using {@link stream}.
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<TEntity>;
+}

package/endpoints/reactive/GenericStreamingCollectionEndpoint.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericStreamingCollectionEndpoint = void 0;
+const GenericCollectionEndpoint_1 = require("../generic/GenericCollectionEndpoint");
+const Delay_1 = require("./Delay");
+const http_1 = require("../../http");
+const errors_1 = require("../../errors");
+/**
+ * Endpoint for a collection of `TEntity`s observable as an append-only stream using long-polling.<br>
+ * Use {@link StreamingCollectionEndpoint} instead if you wish to use the default {@link ElementEndpoint} type.
+ * @typeParam TEntity The type of individual elements in the collection.
+ * @typeParam TElementEndpoint The type of {@link ElementEndpoint} to provide for individual `TEntity`s.
+ */
+class GenericStreamingCollectionEndpoint extends GenericCollectionEndpoint_1.GenericCollectionEndpoint {
+    constructor() {
+        super(...arguments);
+        /**
+         * The interval in milliseconds to wait between polling requests.
+         * Automatically updated whenever the server sends a {@link http!HttpHeader.RetryAfter} header.
+         */
+        this.pollingInterval = 3000;
+    }
+    /**
+     * @inheritDoc
+     */
+    async handle(response) {
+        var _a;
+        await super.handle(response);
+        this.pollingInterval = (_a = (0, http_1.retryAfter)(response)) !== null && _a !== void 0 ? _a : this.pollingInterval;
+    }
+    /**
+     * Provides a stream of `TEntity`s, polling the server for elements appended to the collection.
+     * @param startIndex The index of the first element to return. Use a negative value to start with the last `-startIndex` elements ("tail").
+     * @param signal Used to stop polling.
+     * @throws {@link errors!AuthenticationError}: {@link http!HttpStatusCode.Unauthorized}
+     * @throws {@link errors!AuthorizationError}: {@link http!HttpStatusCode.Forbidden}
+     * @throws {@link errors!HttpError}: Other non-success status code
+     */
+    async *stream(startIndex = 0, signal) {
+        var _a;
+        let currentStartIndex = startIndex;
+        while (!(signal === null || signal === void 0 ? void 0 : signal.aborted)) {
+            let response;
+            try {
+                response = (currentStartIndex >= 0)
+                    // Offset
+                    ? await this.readRange(currentStartIndex, undefined, signal)
+                    // Tail
+                    : await this.readRange(undefined, -currentStartIndex, signal);
+            }
+            catch (err) {
+                // Aborting is a regular way of ending the stream, not an error
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+                    return;
+                if (!(err instanceof errors_1.RangeNotSatisfiableError))
+                    throw err;
+                // No new data available yet, keep polling
+                if (!await (0, Delay_1.delay)(this.pollingInterval, signal))
+                    return;
+                continue;
+            }
+            yield* response.elements;
+            if (response.endReached)
+                return;
+            // Continue polling for more data
+            if (((_a = response.range) === null || _a === void 0 ? void 0 : _a.to) === undefined)
+                return;
+            currentStartIndex = response.range.to + 1;
+            if (!await (0, Delay_1.delay)(this.pollingInterval, signal))
+                return;
+        }
+    }
+    /**
+     * Provides a stream of `TEntity`s using {@link stream}.
+     */
+    [Symbol.asyncIterator]() { return this.stream(); }
+}
+exports.GenericStreamingCollectionEndpoint = GenericStreamingCollectionEndpoint;
+//# sourceMappingURL=data:application/json;base64,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

package/endpoints/reactive/PollingEndpoint.d.ts

@@ -0,0 +1,39 @@
+import { ElementEndpoint } from "../generic/ElementEndpoint";
+import { Endpoint } from "../Endpoint";
+/**
+ * Endpoint for a resource that can be polled for state changes.
+ * @typeParam TEntity The type of entity the endpoint represents.
+ */
+export declare class PollingEndpoint<TEntity> extends ElementEndpoint<TEntity> {
+    private readonly endCondition?;
+    /**
+     * Creates a new polling endpoint.
+     * @param referrer The endpoint used to navigate to this one.
+     * @param relativeUri The URI of this endpoint relative to the `referrer`'s. Add a `./` prefix here to imply a trailing slash in the `referrer`'s URI.
+     * @param endCondition A check to determine whether the entity has reached its final state and no further polling is required.
+     */
+    constructor(referrer: Endpoint, relativeUri: URL | string, endCondition?: ((entity: TEntity) => boolean) | undefined);
+    /**
+     * The interval in milliseconds to wait between polling requests.
+     * Automatically updated whenever the server sends a {@link http!HttpHeader.RetryAfter} header.
+     */
+    pollingInterval: number;
+    /**
+     * @inheritDoc
+     */
+    protected handle(response: Response): Promise<void>;
+    /**
+     * Provides a stream of the `TEntity`'s states, polling the server for changes.
+     * States that are identical to the previously provided one are skipped.
+     * @param signal Used to stop polling.
+     * @throws {@link errors!AuthenticationError}: {@link http!HttpStatusCode.Unauthorized}
+     * @throws {@link errors!AuthorizationError}: {@link http!HttpStatusCode.Forbidden}
+     * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
+     * @throws {@link errors!HttpError}: Other non-success status code
+     */
+    stream(signal?: AbortSignal): AsyncIterableIterator<TEntity>;
+    /**
+     * Provides a stream of the `TEntity`'s states using {@link stream}.
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<TEntity>;
+}

package/endpoints/reactive/PollingEndpoint.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingEndpoint = void 0;
+const ElementEndpoint_1 = require("../generic/ElementEndpoint");
+const Delay_1 = require("./Delay");
+const http_1 = require("../../http");
+/**
+ * Endpoint for a resource that can be polled for state changes.
+ * @typeParam TEntity The type of entity the endpoint represents.
+ */
+class PollingEndpoint extends ElementEndpoint_1.ElementEndpoint {
+    /**
+     * Creates a new polling endpoint.
+     * @param referrer The endpoint used to navigate to this one.
+     * @param relativeUri The URI of this endpoint relative to the `referrer`'s. Add a `./` prefix here to imply a trailing slash in the `referrer`'s URI.
+     * @param endCondition A check to determine whether the entity has reached its final state and no further polling is required.
+     */
+    constructor(referrer, relativeUri, endCondition) {
+        super(referrer, relativeUri);
+        this.endCondition = endCondition;
+        /**
+         * The interval in milliseconds to wait between polling requests.
+         * Automatically updated whenever the server sends a {@link http!HttpHeader.RetryAfter} header.
+         */
+        this.pollingInterval = 3000;
+    }
+    /**
+     * @inheritDoc
+     */
+    async handle(response) {
+        var _a;
+        await super.handle(response);
+        this.pollingInterval = (_a = (0, http_1.retryAfter)(response)) !== null && _a !== void 0 ? _a : this.pollingInterval;
+    }
+    /**
+     * Provides a stream of the `TEntity`'s states, polling the server for changes.
+     * States that are identical to the previously provided one are skipped.
+     * @param signal Used to stop polling.
+     * @throws {@link errors!AuthenticationError}: {@link http!HttpStatusCode.Unauthorized}
+     * @throws {@link errors!AuthorizationError}: {@link http!HttpStatusCode.Forbidden}
+     * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
+     * @throws {@link errors!HttpError}: Other non-success status code
+     */
+    async *stream(signal) {
+        var _a;
+        // NOTE: Compare the serialized form because every poll deserializes a new object instance.
+        let previous;
+        while (!(signal === null || signal === void 0 ? void 0 : signal.aborted)) {
+            const entity = await this.read(signal);
+            const serialized = this.serializer.serialize(entity);
+            if (serialized !== previous) {
+                previous = serialized;
+                yield entity;
+            }
+            if ((_a = this.endCondition) === null || _a === void 0 ? void 0 : _a.call(this, entity))
+                return;
+            if (!await (0, Delay_1.delay)(this.pollingInterval, signal))
+                return;
+        }
+    }
+    /**
+     * Provides a stream of the `TEntity`'s states using {@link stream}.
+     */
+    [Symbol.asyncIterator]() { return this.stream(); }
+}
+exports.PollingEndpoint = PollingEndpoint;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUG9sbGluZ0VuZHBvaW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiUG9sbGluZ0VuZHBvaW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLGdFQUE2RDtBQUU3RCxtQ0FBZ0M7QUFDaEMscUNBQXdDO0FBRXhDOzs7R0FHRztBQUNILE1BQWEsZUFBeUIsU0FBUSxpQ0FBd0I7SUFDbEU7Ozs7O09BS0c7SUFDSCxZQUFZLFFBQWtCLEVBQUUsV0FBeUIsRUFBbUIsWUFBMkM7UUFDbkgsS0FBSyxDQUFDLFFBQVEsRUFBRSxXQUFXLENBQUMsQ0FBQztRQUQyQyxpQkFBWSxHQUFaLFlBQVksQ0FBK0I7UUFJdkg7OztXQUdHO1FBQ0gsb0JBQWUsR0FBRyxJQUFJLENBQUM7SUFOdkIsQ0FBQztJQVFEOztPQUVHO0lBQ08sS0FBSyxDQUFDLE1BQU0sQ0FBQyxRQUFrQjs7UUFDckMsTUFBTSxLQUFLLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQzdCLElBQUksQ0FBQyxlQUFlLEdBQUcsTUFBQSxJQUFBLGlCQUFVLEVBQUMsUUFBUSxDQUFDLG1DQUFJLElBQUksQ0FBQyxlQUFlLENBQUM7SUFDeEUsQ0FBQztJQUVEOzs7Ozs7OztPQVFHO0lBQ0gsS0FBSyxDQUFDLENBQUMsTUFBTSxDQUFDLE1BQW9COztRQUM5QiwyRkFBMkY7UUFDM0YsSUFBSSxRQUE0QixDQUFDO1FBRWpDLE9BQU8sQ0FBQyxDQUFBLE1BQU0sYUFBTixNQUFNLHVCQUFOLE1BQU0sQ0FBRSxPQUFPLENBQUEsRUFBRSxDQUFDO1lBQ3RCLE1BQU0sTUFBTSxHQUFHLE1BQU0sSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztZQUV2QyxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQztZQUNyRCxJQUFJLFVBQVUsS0FBSyxRQUFRLEVBQUUsQ0FBQztnQkFDMUIsUUFBUSxHQUFHLFVBQVUsQ0FBQztnQkFDdEIsTUFBTSxNQUFNLENBQUM7WUFDakIsQ0FBQztZQUVELElBQUksTUFBQSxJQUFJLENBQUMsWUFBWSxxREFBRyxNQUFNLENBQUM7Z0JBQUUsT0FBTztZQUN4QyxJQUFJLENBQUMsTUFBTSxJQUFBLGFBQUssRUFBQyxJQUFJLENBQUMsZUFBZSxFQUFFLE1BQU0sQ0FBQztnQkFBRSxPQUFPO1FBQzNELENBQUM7SUFDTCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxDQUFDLE1BQU0sQ0FBQyxhQUFhLENBQUMsS0FBSyxPQUFPLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDLENBQUM7Q0FDckQ7QUF4REQsMENBd0RDIn0=

package/endpoints/reactive/SseStreamingEndpoint.d.ts

@@ -0,0 +1,50 @@
+import { Endpoint } from "../Endpoint";
+/**
+ * Endpoint for a stream of `TEntity`s using Server-Sent Events (SSE).<br>
+ * Sends `Accept: text/event-stream`. By default, transparently reconnects on connection drops or transient errors,
+ * honoring the server-supplied `retry:` interval and resuming via the {@link http!HttpHeader.LastEventId} header.
+ * @typeParam TEntity The type of individual elements in the stream.
+ */
+export declare class SseStreamingEndpoint<TEntity> extends Endpoint {
+    private readonly eventType?;
+    /**
+     * Creates a new SSE streaming endpoint.
+     * @param referrer The endpoint used to navigate to this one.
+     * @param relativeUri The URI of this endpoint relative to the `referrer`'s. Add a `./` prefix here to imply a trailing slash in the `referrer`'s URI.
+     * @param eventType If set, only events with this `event:` type are provided; others are ignored. Leave unspecified to provide all events.
+     */
+    constructor(referrer: Endpoint, relativeUri: URL | string, eventType?: string | undefined);
+    /**
+     * Whether to transparently reconnect on connection drops, transient transport errors and 5xx responses.
+     */
+    autoReconnect: boolean;
+    /**
+     * The reconnection interval in milliseconds used when the server has not (yet) supplied one via the SSE `retry:` field.
+     */
+    defaultReconnectionInterval: number;
+    /**
+     * Provides a stream of `TEntity`s, reconnecting as needed unless {@link autoReconnect} is disabled.
+     * @param signal Used to close the connection.
+     * @throws {@link errors!AuthenticationError}: {@link http!HttpStatusCode.Unauthorized}
+     * @throws {@link errors!AuthorizationError}: {@link http!HttpStatusCode.Forbidden}
+     * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
+     * @throws {@link errors!HttpError}: Other non-success status code
+     */
+    stream(signal?: AbortSignal): AsyncIterableIterator<TEntity>;
+    /**
+     * Provides a stream of `TEntity`s using {@link stream}.
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<TEntity>;
+    /**
+     * Opens a connection and provides events until the stream ends.
+     * @param state Carries the last event id and the reconnection interval over to the next attempt.
+     * @param signal Used to close the connection.
+     * @returns `true` if another connection attempt should be made; `false` if the stream has ended for good.
+     */
+    private consumeOnce;
+    /**
+     * Determines whether an error is a transport-level failure that may succeed on a retry.
+     * The Fetch API reports these as `TypeError`s, while responses the server actually sent become {@link errors!HttpError}s.
+     */
+    private static isTransient;
+}

package/endpoints/reactive/SseStreamingEndpoint.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SseStreamingEndpoint = void 0;
+const Endpoint_1 = require("../Endpoint");
+const Delay_1 = require("./Delay");
+const http_1 = require("../../http");
+const eventStreamMediaType = "text/event-stream";
+/**
+ * Endpoint for a stream of `TEntity`s using Server-Sent Events (SSE).<br>
+ * Sends `Accept: text/event-stream`. By default, transparently reconnects on connection drops or transient errors,
+ * honoring the server-supplied `retry:` interval and resuming via the {@link http!HttpHeader.LastEventId} header.
+ * @typeParam TEntity The type of individual elements in the stream.
+ */
+class SseStreamingEndpoint extends Endpoint_1.Endpoint {
+    /**
+     * Creates a new SSE streaming endpoint.
+     * @param referrer The endpoint used to navigate to this one.
+     * @param relativeUri The URI of this endpoint relative to the `referrer`'s. Add a `./` prefix here to imply a trailing slash in the `referrer`'s URI.
+     * @param eventType If set, only events with this `event:` type are provided; others are ignored. Leave unspecified to provide all events.
+     */
+    constructor(referrer, relativeUri, eventType) {
+        super(referrer, relativeUri);
+        this.eventType = eventType;
+        /**
+         * Whether to transparently reconnect on connection drops, transient transport errors and 5xx responses.
+         */
+        this.autoReconnect = true;
+        /**
+         * The reconnection interval in milliseconds used when the server has not (yet) supplied one via the SSE `retry:` field.
+         */
+        this.defaultReconnectionInterval = 3000;
+    }
+    /**
+     * Provides a stream of `TEntity`s, reconnecting as needed unless {@link autoReconnect} is disabled.
+     * @param signal Used to close the connection.
+     * @throws {@link errors!AuthenticationError}: {@link http!HttpStatusCode.Unauthorized}
+     * @throws {@link errors!AuthorizationError}: {@link http!HttpStatusCode.Forbidden}
+     * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
+     * @throws {@link errors!HttpError}: Other non-success status code
+     */
+    async *stream(signal) {
+        const state = { lastEventId: undefined, reconnectionInterval: this.defaultReconnectionInterval };
+        while (!(signal === null || signal === void 0 ? void 0 : signal.aborted)) {
+            let reconnect;
+            try {
+                reconnect = yield* this.consumeOnce(state, signal);
+            }
+            catch (err) {
+                // Aborting is a regular way of ending the stream, not an error
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+                    return;
+                // Transport-level failures are the ones worth retrying; anything else is the server telling us no
+                if (!this.autoReconnect || !SseStreamingEndpoint.isTransient(err))
+                    throw err;
+                reconnect = true;
+            }
+            if (!reconnect)
+                return;
+            if (!await (0, Delay_1.delay)(state.reconnectionInterval, signal))
+                return;
+        }
+    }
+    /**
+     * Provides a stream of `TEntity`s using {@link stream}.
+     */
+    [Symbol.asyncIterator]() { return this.stream(); }
+    /**
+     * Opens a connection and provides events until the stream ends.
+     * @param state Carries the last event id and the reconnection interval over to the next attempt.
+     * @param signal Used to close the connection.
+     * @returns `true` if another connection attempt should be made; `false` if the stream has ended for good.
+     */
+    async *consumeOnce(state, signal) {
+        var _a;
+        // NOTE: Abort the request when the consumer stops iterating, not just when the caller's signal fires.
+        const controller = new AbortController();
+        const onAbort = () => controller.abort();
+        signal === null || signal === void 0 ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+            controller.abort();
+        try {
+            const headers = new Headers({ [http_1.HttpHeader.Accept]: eventStreamMediaType });
+            if (state.lastEventId)
+                headers.set(http_1.HttpHeader.LastEventId, state.lastEventId);
+            const response = await this.httpClient.send(this.uri, http_1.HttpMethod.Get, controller.signal, headers);
+            if (response.status === http_1.HttpStatusCode.NoContent)
+                return false;
+            if (this.autoReconnect && response.status >= 500)
+                return true;
+            await this.handle(response);
+            const reader = new http_1.SseReader(response);
+            try {
+                for await (const event of reader.events()) {
+                    if (this.eventType !== undefined && event.type !== this.eventType)
+                        continue;
+                    yield this.serializer.deserialize(event.data);
+                }
+            }
+            finally {
+                state.lastEventId = (_a = reader.lastEventId) !== null && _a !== void 0 ? _a : state.lastEventId;
+                if (reader.reconnectionInterval !== undefined)
+                    state.reconnectionInterval = reader.reconnectionInterval;
+            }
+            return this.autoReconnect;
+        }
+        finally {
+            signal === null || signal === void 0 ? void 0 : signal.removeEventListener("abort", onAbort);
+            controller.abort();
+        }
+    }
+    /**
+     * Determines whether an error is a transport-level failure that may succeed on a retry.
+     * The Fetch API reports these as `TypeError`s, while responses the server actually sent become {@link errors!HttpError}s.
+     */
+    static isTransient(err) {
+        return err instanceof TypeError;
+    }
+}
+exports.SseStreamingEndpoint = SseStreamingEndpoint;
+//# sourceMappingURL=data:application/json;base64,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

package/endpoints/reactive/StreamingCollectionEndpoint.d.ts

@@ -0,0 +1,17 @@
+import { GenericStreamingCollectionEndpoint } from "./GenericStreamingCollectionEndpoint";
+import { ElementEndpoint } from "../generic/ElementEndpoint";
+import { Endpoint } from "../Endpoint";
+/**
+ * Endpoint for a collection of `TEntity`s observable as an append-only stream using long-polling,
+ * addressable as {@link ElementEndpoint}s.<br>
+ * Use {@link GenericStreamingCollectionEndpoint} instead if you wish to customize the element endpoint type.
+ * @typeParam TEntity The type of individual elements in the collection.
+ */
+export declare class StreamingCollectionEndpoint<TEntity> extends GenericStreamingCollectionEndpoint<TEntity, ElementEndpoint<TEntity>> {
+    /**
+     * Creates a new streaming collection endpoint.
+     * @param referrer The endpoint used to navigate to this one.
+     * @param relativeUri The URI of this endpoint relative to the `referrer`'s. Add a `./` prefix here to imply a trailing slash in the `referrer`'s URI.
+     */
+    constructor(referrer: Endpoint, relativeUri: URL | string);
+}

package/endpoints/reactive/StreamingCollectionEndpoint.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingCollectionEndpoint = void 0;
+const GenericStreamingCollectionEndpoint_1 = require("./GenericStreamingCollectionEndpoint");
+const ElementEndpoint_1 = require("../generic/ElementEndpoint");
+/**
+ * Endpoint for a collection of `TEntity`s observable as an append-only stream using long-polling,
+ * addressable as {@link ElementEndpoint}s.<br>
+ * Use {@link GenericStreamingCollectionEndpoint} instead if you wish to customize the element endpoint type.
+ * @typeParam TEntity The type of individual elements in the collection.
+ */
+class StreamingCollectionEndpoint extends GenericStreamingCollectionEndpoint_1.GenericStreamingCollectionEndpoint {
+    /**
+     * Creates a new streaming collection endpoint.
+     * @param referrer The endpoint used to navigate to this one.
+     * @param relativeUri The URI of this endpoint relative to the `referrer`'s. Add a `./` prefix here to imply a trailing slash in the `referrer`'s URI.
+     */
+    constructor(referrer, relativeUri) {
+        super(referrer, relativeUri, ElementEndpoint_1.ElementEndpoint);
+    }
+}
+exports.StreamingCollectionEndpoint = StreamingCollectionEndpoint;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3RyZWFtaW5nQ29sbGVjdGlvbkVuZHBvaW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiU3RyZWFtaW5nQ29sbGVjdGlvbkVuZHBvaW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDZGQUEwRjtBQUMxRixnRUFBNkQ7QUFHN0Q7Ozs7O0dBS0c7QUFDSCxNQUFhLDJCQUFxQyxTQUFRLHVFQUFxRTtJQUMzSDs7OztPQUlHO0lBQ0gsWUFBWSxRQUFrQixFQUFFLFdBQXlCO1FBQ3JELEtBQUssQ0FBQyxRQUFRLEVBQUUsV0FBVyxFQUFFLGlDQUFlLENBQUMsQ0FBQztJQUNsRCxDQUFDO0NBQ0o7QUFURCxrRUFTQyJ9

package/endpoints/reactive/StreamingEndpoint.d.ts

@@ -0,0 +1,28 @@
+import { Endpoint } from "../Endpoint";
+/**
+ * Endpoint for a stream of `TEntity`s using a persistent HTTP connection.
+ * @typeParam TEntity The type of individual elements in the stream.
+ */
+export declare class StreamingEndpoint<TEntity> extends Endpoint {
+    private readonly separator;
+    /**
+     * Creates a new streaming endpoint.
+     * @param referrer The endpoint used to navigate to this one.
+     * @param relativeUri The URI of this endpoint relative to the `referrer`'s. Add a `./` prefix here to imply a trailing slash in the `referrer`'s URI.
+     * @param separator The character sequence used to detect that a new element starts in the HTTP stream.
+     */
+    constructor(referrer: Endpoint, relativeUri: URL | string, separator?: string);
+    /**
+     * Provides a stream of `TEntity`s, keeping the HTTP connection open until the server closes it.
+     * @param signal Used to close the connection.
+     * @throws {@link errors!AuthenticationError}: {@link http!HttpStatusCode.Unauthorized}
+     * @throws {@link errors!AuthorizationError}: {@link http!HttpStatusCode.Forbidden}
+     * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
+     * @throws {@link errors!HttpError}: Other non-success status code
+     */
+    stream(signal?: AbortSignal): AsyncIterableIterator<TEntity>;
+    /**
+     * Provides a stream of `TEntity`s using {@link stream}.
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<TEntity>;
+}

package/endpoints/reactive/StreamingEndpoint.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingEndpoint = void 0;
+const Endpoint_1 = require("../Endpoint");
+const http_1 = require("../../http");
+/**
+ * Endpoint for a stream of `TEntity`s using a persistent HTTP connection.
+ * @typeParam TEntity The type of individual elements in the stream.
+ */
+class StreamingEndpoint extends Endpoint_1.Endpoint {
+    /**
+     * Creates a new streaming endpoint.
+     * @param referrer The endpoint used to navigate to this one.
+     * @param relativeUri The URI of this endpoint relative to the `referrer`'s. Add a `./` prefix here to imply a trailing slash in the `referrer`'s URI.
+     * @param separator The character sequence used to detect that a new element starts in the HTTP stream.
+     */
+    constructor(referrer, relativeUri, separator = "\n") {
+        super(referrer, relativeUri);
+        this.separator = separator;
+    }
+    /**
+     * Provides a stream of `TEntity`s, keeping the HTTP connection open until the server closes it.
+     * @param signal Used to close the connection.
+     * @throws {@link errors!AuthenticationError}: {@link http!HttpStatusCode.Unauthorized}
+     * @throws {@link errors!AuthorizationError}: {@link http!HttpStatusCode.Forbidden}
+     * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
+     * @throws {@link errors!HttpError}: Other non-success status code
+     */
+    async *stream(signal) {
+        // NOTE: Abort the request when the consumer stops iterating, not just when the caller's signal fires.
+        const controller = new AbortController();
+        const onAbort = () => controller.abort();
+        signal === null || signal === void 0 ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+            controller.abort();
+        try {
+            const response = await this.send(http_1.HttpMethod.Get, controller.signal);
+            yield* (0, http_1.entityStream)(response, this.serializer, this.separator);
+        }
+        catch (err) {
+            // Aborting is a regular way of ending the stream, not an error
+            if (!(signal === null || signal === void 0 ? void 0 : signal.aborted))
+                throw err;
+        }
+        finally {
+            signal === null || signal === void 0 ? void 0 : signal.removeEventListener("abort", onAbort);
+            controller.abort();
+        }
+    }
+    /**
+     * Provides a stream of `TEntity`s using {@link stream}.
+     */
+    [Symbol.asyncIterator]() { return this.stream(); }
+}
+exports.StreamingEndpoint = StreamingEndpoint;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3RyZWFtaW5nRW5kcG9pbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJTdHJlYW1pbmdFbmRwb2ludC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwwQ0FBdUM7QUFDdkMscUNBQXNEO0FBRXREOzs7R0FHRztBQUNILE1BQWEsaUJBQTJCLFNBQVEsbUJBQVE7SUFDcEQ7Ozs7O09BS0c7SUFDSCxZQUFZLFFBQWtCLEVBQUUsV0FBeUIsRUFBbUIsWUFBb0IsSUFBSTtRQUNoRyxLQUFLLENBQUMsUUFBUSxFQUFFLFdBQVcsQ0FBQyxDQUFDO1FBRDJDLGNBQVMsR0FBVCxTQUFTLENBQWU7SUFFcEcsQ0FBQztJQUVEOzs7Ozs7O09BT0c7SUFDSCxLQUFLLENBQUMsQ0FBQyxNQUFNLENBQUMsTUFBb0I7UUFDOUIsc0dBQXNHO1FBQ3RHLE1BQU0sVUFBVSxHQUFHLElBQUksZUFBZSxFQUFFLENBQUM7UUFDekMsTUFBTSxPQUFPLEdBQUcsR0FBRyxFQUFFLENBQUMsVUFBVSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ3pDLE1BQU0sYUFBTixNQUFNLHVCQUFOLE1BQU0sQ0FBRSxnQkFBZ0IsQ0FBQyxPQUFPLEVBQUUsT0FBTyxFQUFFLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7UUFDM0QsSUFBSSxNQUFNLGFBQU4sTUFBTSx1QkFBTixNQUFNLENBQUUsT0FBTztZQUFFLFVBQVUsQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUV4QyxJQUFJLENBQUM7WUFDRCxNQUFNLFFBQVEsR0FBRyxNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsaUJBQVUsQ0FBQyxHQUFHLEVBQUUsVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1lBQ3BFLEtBQUssQ0FBQyxDQUFDLElBQUEsbUJBQVksRUFBVSxRQUFRLEVBQUUsSUFBSSxDQUFDLFVBQVUsRUFBRSxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDNUUsQ0FBQztRQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7WUFDWCwrREFBK0Q7WUFDL0QsSUFBSSxDQUFDLENBQUEsTUFBTSxhQUFOLE1BQU0sdUJBQU4sTUFBTSxDQUFFLE9BQU8sQ0FBQTtnQkFBRSxNQUFNLEdBQUcsQ0FBQztRQUNwQyxDQUFDO2dCQUFTLENBQUM7WUFDUCxNQUFNLGFBQU4sTUFBTSx1QkFBTixNQUFNLENBQUUsbUJBQW1CLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDO1lBQzlDLFVBQVUsQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUN2QixDQUFDO0lBQ0wsQ0FBQztJQUVEOztPQUVHO0lBQ0gsQ0FBQyxNQUFNLENBQUMsYUFBYSxDQUFDLEtBQUssT0FBTyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDO0NBQ3JEO0FBMUNELDhDQTBDQyJ9

package/endpoints/reactive/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./PollingEndpoint";
+export * from "./StreamingEndpoint";
+export * from "./SseStreamingEndpoint";
+export * from "./GenericStreamingCollectionEndpoint";
+export * from "./StreamingCollectionEndpoint";

package/endpoints/reactive/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./PollingEndpoint"), exports);
+__exportStar(require("./StreamingEndpoint"), exports);
+__exportStar(require("./SseStreamingEndpoint"), exports);
+__exportStar(require("./GenericStreamingCollectionEndpoint"), exports);
+__exportStar(require("./StreamingCollectionEndpoint"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsb0RBQWtDO0FBQ2xDLHNEQUFvQztBQUNwQyx5REFBdUM7QUFDdkMsdUVBQXFEO0FBQ3JELGdFQUE4QyJ9

package/endpoints/rpc/{ActionEndpoint.ts → ActionEndpoint.d.ts}

@@ -1,20 +1,15 @@
 import { RpcEndpointBase } from "./RpcEndpointBase";
 import { Endpoint } from "../Endpoint";
-import { HttpMethod } from "../../http";
-
 /**
  * RPC endpoint that is invoked with no input or output.
  */
-export class ActionEndpoint extends RpcEndpointBase {
+export declare class ActionEndpoint extends RpcEndpointBase {
     /**
      * Creates a new action endpoint.
      * @param referrer The endpoint used to navigate to this one.
      * @param relativeUri The URI of this endpoint relative to the `referrer`'s. Add a `./` prefix here to imply a trailing slash in the `referrer`'s URI.
      */
-    constructor(referrer: Endpoint, relativeUri: URL | string) {
-        super(referrer, relativeUri);
-    }
-
+    constructor(referrer: Endpoint, relativeUri: URL | string);
     /**
      * Invokes the action.
      * @param signal Used to cancel the request.
@@ -23,7 +18,5 @@ export class ActionEndpoint extends RpcEndpointBase {
      * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
      * @throws {@link errors!HttpError}: Other non-success status code
      */
-    async invoke(signal?: AbortSignal) {
-        await this.send(HttpMethod.Post, signal);
-    }
+    invoke(signal?: AbortSignal): Promise<void>;
 }

package/endpoints/rpc/ActionEndpoint.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActionEndpoint = void 0;
 const RpcEndpointBase_1 = require("./RpcEndpointBase");
@@ -32,11 +23,9 @@ class ActionEndpoint extends RpcEndpointBase_1.RpcEndpointBase {
      * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
      * @throws {@link errors!HttpError}: Other non-success status code
      */
-    invoke(signal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.send(http_1.HttpMethod.Post, signal);
-        });
+    async invoke(signal) {
+        await this.send(http_1.HttpMethod.Post, signal);
     }
 }
 exports.ActionEndpoint = ActionEndpoint;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWN0aW9uRW5kcG9pbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJBY3Rpb25FbmRwb2ludC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSx1REFBb0Q7QUFFcEQscUNBQXdDO0FBRXhDOztHQUVHO0FBQ0gsTUFBYSxjQUFlLFNBQVEsaUNBQWU7SUFDL0M7Ozs7T0FJRztJQUNILFlBQVksUUFBa0IsRUFBRSxXQUF5QjtRQUNyRCxLQUFLLENBQUMsUUFBUSxFQUFFLFdBQVcsQ0FBQyxDQUFDO0lBQ2pDLENBQUM7SUFFRDs7Ozs7OztPQU9HO0lBQ0csTUFBTSxDQUFDLE1BQW9COztZQUM3QixNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsaUJBQVUsQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFDN0MsQ0FBQztLQUFBO0NBQ0o7QUFyQkQsd0NBcUJDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWN0aW9uRW5kcG9pbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJBY3Rpb25FbmRwb2ludC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx1REFBb0Q7QUFFcEQscUNBQXdDO0FBRXhDOztHQUVHO0FBQ0gsTUFBYSxjQUFlLFNBQVEsaUNBQWU7SUFDL0M7Ozs7T0FJRztJQUNILFlBQVksUUFBa0IsRUFBRSxXQUF5QjtRQUNyRCxLQUFLLENBQUMsUUFBUSxFQUFFLFdBQVcsQ0FBQyxDQUFDO0lBQ2pDLENBQUM7SUFFRDs7Ozs7OztPQU9HO0lBQ0gsS0FBSyxDQUFDLE1BQU0sQ0FBQyxNQUFvQjtRQUM3QixNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsaUJBQVUsQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDN0MsQ0FBQztDQUNKO0FBckJELHdDQXFCQyJ9