typedrest 0.4.1 → 0.5.0

package/endpoints/generic/GenericCollectionEndpoint.test.ts

@@ -0,0 +1,123 @@
+/**
+ * NOTE: The jsdom environment strips the "Range" request header, so these tests need the node environment.
+ * @jest-environment node
+ */
+
+import fetchMock from 'jest-fetch-mock';
+import { CollectionEndpoint } from '.';
+import { EntryEndpoint } from '..';
+import { HttpHeader, HttpStatusCode, HttpContentRange } from '../../http';
+import { RangeNotSatisfiableError } from '../../errors';
+
+class MockEntity {
+    constructor(public id: number, public name: string) { }
+}
+
+fetchMock.enableMocks();
+let endpoint: CollectionEndpoint<MockEntity>;
+
+beforeEach(() => {
+    fetchMock.resetMocks();
+    endpoint = new CollectionEndpoint(new EntryEndpoint('http://localhost/'), 'endpoint');
+});
+
+test('readRange', async () => {
+    fetchMock.mockOnceIf(
+        'http://localhost/endpoint',
+        async req => {
+            expect(req.headers.get(HttpHeader.Range)).toBe('elements=1-2');
+            return {
+                body: '[{"id":6,"name":"test2"}, {"id":7,"name":"test3"}]',
+                status: HttpStatusCode.PartialContent,
+                headers: {
+                    [HttpHeader.ContentRange]: 'elements 1-2/3'
+                }
+            };
+        }
+    );
+
+    const result = await endpoint.readRange(1, 2);
+    expect(result.elements).toEqual([new MockEntity(6, 'test2'), new MockEntity(7, 'test3')]);
+    expect(result.range).toEqual(new HttpContentRange('elements', 1, 2, 3));
+    expect(result.endReached).toBe(true);
+});
+
+test('readRangeOffset', async () => {
+    fetchMock.mockOnceIf(
+        'http://localhost/endpoint',
+        async req => {
+            expect(req.headers.get(HttpHeader.Range)).toBe('elements=1-');
+            return {
+                body: '[{"id":6,"name":"test2"}]',
+                status: HttpStatusCode.PartialContent,
+                headers: {
+                    [HttpHeader.ContentRange]: 'elements 1-1/*'
+                }
+            };
+        }
+    );
+
+    const result = await endpoint.readRange(1);
+    expect(result.elements).toEqual([new MockEntity(6, 'test2')]);
+    expect(result.range).toEqual(new HttpContentRange('elements', 1, 1, undefined));
+    expect(result.endReached).toBe(false);
+});
+
+test('readRangeTail', async () => {
+    fetchMock.mockOnceIf(
+        'http://localhost/endpoint',
+        async req => {
+            expect(req.headers.get(HttpHeader.Range)).toBe('elements=-1');
+            return {
+                body: '[{"id":6,"name":"test2"}]',
+                status: HttpStatusCode.PartialContent
+            };
+        }
+    );
+
+    const result = await endpoint.readRange(undefined, 1);
+    expect(result.elements).toEqual([new MockEntity(6, 'test2')]);
+    expect(result.range).toBeUndefined();
+    expect(result.endReached).toBe(true);
+});
+
+test('readRangeNotSatisfiable', async () => {
+    fetchMock.mockOnceIf(
+        'http://localhost/endpoint',
+        async () => ({ status: HttpStatusCode.RangeNotSatisfiable })
+    );
+
+    await expect(endpoint.readRange(1)).rejects.toThrow(RangeNotSatisfiableError);
+});
+
+test('readRangeAllowed', async () => {
+    expect(endpoint.readRangeAllowed).toBeUndefined();
+
+    fetchMock.mockOnceIf(
+        'http://localhost/endpoint',
+        '[]',
+        {
+            headers: {
+                [HttpHeader.AcceptRanges]: 'elements'
+            }
+        }
+    );
+    await endpoint.readAll();
+
+    expect(endpoint.readRangeAllowed).toBe(true);
+});
+
+test('readRangeNotAllowed', async () => {
+    fetchMock.mockOnceIf(
+        'http://localhost/endpoint',
+        '[]',
+        {
+            headers: {
+                [HttpHeader.AcceptRanges]: 'none'
+            }
+        }
+    );
+    await endpoint.readAll();
+
+    expect(endpoint.readRangeAllowed).toBe(false);
+});

package/endpoints/generic/GenericCollectionEndpoint.ts

@@ -1,8 +1,9 @@
 import { ETagEndpointBase } from "./ETagEndpointBase";
 import { ElementEndpoint } from "./ElementEndpoint";
+import { PartialResponse } from "./PartialResponse";
 import { Endpoint } from "../Endpoint";
 import { CachingEndpoint } from "../CachingEndpoint";
-import { HttpMethod, HttpHeader, ResponseCache } from "../../http";
+import { HttpMethod, HttpHeader, HttpContentRange, ResponseCache } from "../../http";
 
 /**
  * Endpoint for a collection of `TEntity`s addressable as `TElementEndpoint`s.<br>
@@ -60,6 +61,58 @@ export class GenericCollectionEndpoint<TEntity, TElementEndpoint extends Element
         return this.serializer.deserialize<TEntity[]>(await this.getContent(signal));
     }
 
+    /**
+     * The unit used when requesting ranges of elements. Sent in the {@link http!HttpHeader.Range} header.
+     */
+    rangeUnit = "elements";
+
+    // NOTE: Only modified when the server reports its capabilities.
+    private acceptedRangeUnits: string[] = [];
+
+    /**
+     * @inheritDoc
+     */
+    protected handleCapabilities(response: Response) {
+        super.handleCapabilities(response);
+
+        const header = response.headers.get(HttpHeader.AcceptRanges);
+        if (header) {
+            this.acceptedRangeUnits = header.split(",").map(x => x.trim());
+        }
+    }
+
+    /**
+     * Shows whether the server has indicated that {@link readRange} is currently allowed.
+     * Uses cached data from last response.
+     * @returns `true` if the method is allowed, `false` if the method is not allowed, `undefined` if no request has been sent yet or the server did not specify accepted range units.
+     */
+    get readRangeAllowed(): boolean | undefined {
+        if (this.acceptedRangeUnits.length === 0)
+            return undefined;
+
+        return this.acceptedRangeUnits.indexOf(this.rangeUnit) !== -1;
+    }
+
+    /**
+     * Returns a subset of the `TEntity`s in the collection.
+     * @param from The index of the first element to return. Leave unspecified to return the last `to` elements ("tail").
+     * @param to The index of the last element to return. Leave unspecified to return all elements starting at `from`.
+     * @param signal Used to cancel the request.
+     * @throws {@link errors!AuthenticationError}: {@link http!HttpStatusCode.Unauthorized}
+     * @throws {@link errors!AuthorizationError}: {@link http!HttpStatusCode.Forbidden}
+     * @throws {@link errors!RangeNotSatisfiableError}: {@link http!HttpStatusCode.RangeNotSatisfiable}, i.e. the requested range lies outside of the elements currently available
+     * @throws {@link errors!HttpError}: Other non-success status code
+     */
+    async readRange(from?: number, to?: number, signal?: AbortSignal): Promise<PartialResponse<TEntity>> {
+        const response = await this.send(HttpMethod.Get, signal, {
+            [HttpHeader.Range]: `${this.rangeUnit}=${from ?? ""}-${to ?? ""}`
+        });
+
+        return new PartialResponse<TEntity>(
+            this.serializer.deserialize<TEntity[]>(await response.text()),
+            HttpContentRange.from(response));
+    }
+
     /**
      * Shows whether the server has indicated that {@link create} is currently allowed.
      * Uses cached data from last response.

package/endpoints/generic/PartialResponse.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartialResponse = void 0;
+/**
+ * Represents a subset of a set of elements.
+ * @typeParam TEntity The type of element the response contains.
+ */
+class PartialResponse {
+    /**
+     * Creates a new partial response.
+     * @param elements The returned elements.
+     * @param range The range the `elements` come from.
+     */
+    constructor(elements, range) {
+        this.elements = elements;
+        this.range = range;
+    }
+    /**
+     * Indicates whether the response reaches the end of the elements available on the server.
+     */
+    get endReached() {
+        var _a;
+        // No range specified, must be complete response
+        if (((_a = this.range) === null || _a === void 0 ? void 0 : _a.to) === undefined)
+            return true;
+        // No length specified, can't be the end
+        if (this.range.length === undefined)
+            return false;
+        return this.range.to === this.range.length - 1;
+    }
+}
+exports.PartialResponse = PartialResponse;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUGFydGlhbFJlc3BvbnNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiUGFydGlhbFJlc3BvbnNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVBOzs7R0FHRztBQUNILE1BQWEsZUFBZTtJQUN4Qjs7OztPQUlHO0lBQ0gsWUFBNEIsUUFBbUIsRUFBa0IsS0FBd0I7UUFBN0QsYUFBUSxHQUFSLFFBQVEsQ0FBVztRQUFrQixVQUFLLEdBQUwsS0FBSyxDQUFtQjtJQUN6RixDQUFDO0lBRUQ7O09BRUc7SUFDSCxJQUFJLFVBQVU7O1FBQ1YsZ0RBQWdEO1FBQ2hELElBQUksQ0FBQSxNQUFBLElBQUksQ0FBQyxLQUFLLDBDQUFFLEVBQUUsTUFBSyxTQUFTO1lBQUUsT0FBTyxJQUFJLENBQUM7UUFFOUMsd0NBQXdDO1FBQ3hDLElBQUksSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLEtBQUssU0FBUztZQUFFLE9BQU8sS0FBSyxDQUFDO1FBRWxELE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxFQUFFLEtBQUssSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDO0lBQ25ELENBQUM7Q0FDSjtBQXJCRCwwQ0FxQkMifQ==

package/endpoints/generic/PartialResponse.ts

@@ -0,0 +1,28 @@
+import { HttpContentRange } from "../../http";
+
+/**
+ * Represents a subset of a set of elements.
+ * @typeParam TEntity The type of element the response contains.
+ */
+export class PartialResponse<TEntity> {
+    /**
+     * Creates a new partial response.
+     * @param elements The returned elements.
+     * @param range The range the `elements` come from.
+     */
+    constructor(public readonly elements: TEntity[], public readonly range?: HttpContentRange) {
+    }
+
+    /**
+     * Indicates whether the response reaches the end of the elements available on the server.
+     */
+    get endReached(): boolean {
+        // No range specified, must be complete response
+        if (this.range?.to === undefined) return true;
+
+        // No length specified, can't be the end
+        if (this.range.length === undefined) return false;
+
+        return this.range.to === this.range.length - 1;
+    }
+}

package/endpoints/generic/index.js

@@ -16,7 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./IndexerEndpoint"), exports);
 __exportStar(require("./ETagEndpointBase"), exports);
+__exportStar(require("./PartialResponse"), exports);
 __exportStar(require("./GenericCollectionEndpoint"), exports);
 __exportStar(require("./CollectionEndpoint"), exports);
 __exportStar(require("./ElementEndpoint"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsb0RBQWtDO0FBQ2xDLHFEQUFtQztBQUNuQyw4REFBNEM7QUFDNUMsdURBQXFDO0FBQ3JDLG9EQUFrQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsb0RBQWtDO0FBQ2xDLHFEQUFtQztBQUNuQyxvREFBa0M7QUFDbEMsOERBQTRDO0FBQzVDLHVEQUFxQztBQUNyQyxvREFBa0MifQ==

package/endpoints/generic/index.ts

@@ -1,5 +1,6 @@
 export * from "./IndexerEndpoint";
 export * from "./ETagEndpointBase";
+export * from "./PartialResponse";
 export * from "./GenericCollectionEndpoint";
 export * from "./CollectionEndpoint";
 export * from "./ElementEndpoint";

package/endpoints/index.js

@@ -36,11 +36,12 @@ 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 });
-exports.raw = exports.rpc = exports.generic = void 0;
+exports.reactive = exports.raw = exports.rpc = exports.generic = void 0;
 exports.generic = __importStar(require("./generic"));
 exports.rpc = __importStar(require("./rpc"));
 exports.raw = __importStar(require("./raw"));
+exports.reactive = __importStar(require("./reactive"));
 __exportStar(require("./Endpoint"), exports);
 __exportStar(require("./EntryEndpoint"), exports);
 __exportStar(require("./CachingEndpoint"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxxREFBcUM7QUFDckMsNkNBQTZCO0FBQzdCLDZDQUE2QjtBQUU3Qiw2Q0FBMkI7QUFDM0Isa0RBQWdDO0FBQ2hDLG9EQUFrQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxxREFBcUM7QUFDckMsNkNBQTZCO0FBQzdCLDZDQUE2QjtBQUM3Qix1REFBdUM7QUFFdkMsNkNBQTJCO0FBQzNCLGtEQUFnQztBQUNoQyxvREFBa0MifQ==

package/endpoints/index.ts

@@ -1,6 +1,7 @@
 export * as generic from "./generic";
 export * as rpc from "./rpc";
 export * as raw from "./raw";
+export * as reactive from "./reactive";
 
 export * from "./Endpoint";
 export * from "./EntryEndpoint";

package/endpoints/raw/BlobEndpoint.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.BlobEndpoint = void 0;
 const Endpoint_1 = require("../Endpoint");
@@ -32,10 +23,8 @@ class BlobEndpoint extends Endpoint_1.Endpoint {
      * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
      * @throws {@link errors!HttpError}: Other non-success status code
      */
-    probe(signal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.send(http_1.HttpMethod.Options, signal);
-        });
+    async probe(signal) {
+        await this.send(http_1.HttpMethod.Options, signal);
     }
     /**
      * Shows whether the server has indicated that {@link download} is currently allowed.
@@ -52,11 +41,9 @@ class BlobEndpoint extends Endpoint_1.Endpoint {
      * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
      * @throws {@link errors!HttpError}: Other non-success status code
      */
-    download(signal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.send(http_1.HttpMethod.Get, signal);
-            return response.blob();
-        });
+    async download(signal) {
+        const response = await this.send(http_1.HttpMethod.Get, signal);
+        return response.blob();
     }
     /**
      * Shows whether the server has indicated that {@link upload} is currently allowed.
@@ -73,10 +60,8 @@ class BlobEndpoint extends Endpoint_1.Endpoint {
      * @throws {@link errors!AuthorizationError}: {@link http!HttpStatusCode.Forbidden}
      * @throws {@link errors!HttpError}: Other non-success status code
      */
-    uploadFrom(blob, signal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.send(http_1.HttpMethod.Put, signal, { [http_1.HttpHeader.ContentType]: blob.type }, blob);
-        });
+    async uploadFrom(blob, signal) {
+        await this.send(http_1.HttpMethod.Put, signal, { [http_1.HttpHeader.ContentType]: blob.type }, blob);
     }
     /**
      * Shows whether the server has indicated that {@link delete} is currently allowed.
@@ -93,11 +78,9 @@ class BlobEndpoint extends Endpoint_1.Endpoint {
      * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
      * @throws {@link errors!HttpError}: Other non-success status code
      */
-    delete(signal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.send(http_1.HttpMethod.Delete, signal);
-        });
+    async delete(signal) {
+        await this.send(http_1.HttpMethod.Delete, signal);
     }
 }
 exports.BlobEndpoint = BlobEndpoint;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQmxvYkVuZHBvaW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiQmxvYkVuZHBvaW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7OztBQUFBLDBDQUF1QztBQUN2QyxxQ0FBb0Q7QUFFcEQ7O0dBRUc7QUFDSCxNQUFhLFlBQWEsU0FBUSxtQkFBUTtJQUN0Qzs7OztPQUlHO0lBQ0gsWUFBWSxRQUFrQixFQUFFLFdBQXlCO1FBQ3JELEtBQUssQ0FBQyxRQUFRLEVBQUUsV0FBVyxDQUFDLENBQUM7SUFDakMsQ0FBQztJQUVEOzs7Ozs7O09BT0c7SUFDRyxLQUFLLENBQUMsTUFBb0I7O1lBQzVCLE1BQU0sSUFBSSxDQUFDLElBQUksQ0FBQyxpQkFBVSxDQUFDLE9BQU8sRUFBRSxNQUFNLENBQUMsQ0FBQztRQUNoRCxDQUFDO0tBQUE7SUFFRDs7OztPQUlHO0lBQ0gsSUFBSSxlQUFlLEtBQUssT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDLGlCQUFVLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRXRFOzs7Ozs7OztPQVFHO0lBQ0csUUFBUSxDQUFDLE1BQW9COztZQUMvQixNQUFNLFFBQVEsR0FBRyxNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsaUJBQVUsQ0FBQyxHQUFHLEVBQUUsTUFBTSxDQUFDLENBQUM7WUFDekQsT0FBTyxRQUFRLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDM0IsQ0FBQztLQUFBO0lBRUQ7Ozs7T0FJRztJQUNILElBQUksYUFBYSxLQUFLLE9BQU8sSUFBSSxDQUFDLGVBQWUsQ0FBQyxpQkFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUVwRTs7Ozs7Ozs7T0FRRztJQUNHLFVBQVUsQ0FBQyxJQUFVLEVBQUUsTUFBb0I7O1lBQzdDLE1BQU0sSUFBSSxDQUFDLElBQUksQ0FBQyxpQkFBVSxDQUFDLEdBQUcsRUFBRSxNQUFNLEVBQUUsRUFBRSxDQUFDLGlCQUFVLENBQUMsV0FBVyxDQUFDLEVBQUUsSUFBSSxDQUFDLElBQUksRUFBRSxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQzNGLENBQUM7S0FBQTtJQUVEOzs7O09BSUc7SUFDSCxJQUFJLGFBQWEsS0FBSyxPQUFPLElBQUksQ0FBQyxlQUFlLENBQUMsaUJBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFFdkU7Ozs7Ozs7O09BUUc7SUFDRyxNQUFNLENBQUMsTUFBb0I7O1lBQzdCLE1BQU0sSUFBSSxDQUFDLElBQUksQ0FBQyxpQkFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FBQztRQUMvQyxDQUFDO0tBQUE7Q0FDSjtBQWxGRCxvQ0FrRkMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQmxvYkVuZHBvaW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiQmxvYkVuZHBvaW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDBDQUF1QztBQUN2QyxxQ0FBb0Q7QUFFcEQ7O0dBRUc7QUFDSCxNQUFhLFlBQWEsU0FBUSxtQkFBUTtJQUN0Qzs7OztPQUlHO0lBQ0gsWUFBWSxRQUFrQixFQUFFLFdBQXlCO1FBQ3JELEtBQUssQ0FBQyxRQUFRLEVBQUUsV0FBVyxDQUFDLENBQUM7SUFDakMsQ0FBQztJQUVEOzs7Ozs7O09BT0c7SUFDSCxLQUFLLENBQUMsS0FBSyxDQUFDLE1BQW9CO1FBQzVCLE1BQU0sSUFBSSxDQUFDLElBQUksQ0FBQyxpQkFBVSxDQUFDLE9BQU8sRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNoRCxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILElBQUksZUFBZSxLQUFLLE9BQU8sSUFBSSxDQUFDLGVBQWUsQ0FBQyxpQkFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUV0RTs7Ozs7Ozs7T0FRRztJQUNILEtBQUssQ0FBQyxRQUFRLENBQUMsTUFBb0I7UUFDL0IsTUFBTSxRQUFRLEdBQUcsTUFBTSxJQUFJLENBQUMsSUFBSSxDQUFDLGlCQUFVLENBQUMsR0FBRyxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBQ3pELE9BQU8sUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDO0lBQzNCLENBQUM7SUFFRDs7OztPQUlHO0lBQ0gsSUFBSSxhQUFhLEtBQUssT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDLGlCQUFVLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRXBFOzs7Ozs7OztPQVFHO0lBQ0gsS0FBSyxDQUFDLFVBQVUsQ0FBQyxJQUFVLEVBQUUsTUFBb0I7UUFDN0MsTUFBTSxJQUFJLENBQUMsSUFBSSxDQUFDLGlCQUFVLENBQUMsR0FBRyxFQUFFLE1BQU0sRUFBRSxFQUFFLENBQUMsaUJBQVUsQ0FBQyxXQUFXLENBQUMsRUFBRSxJQUFJLENBQUMsSUFBSSxFQUFFLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDM0YsQ0FBQztJQUVEOzs7O09BSUc7SUFDSCxJQUFJLGFBQWEsS0FBSyxPQUFPLElBQUksQ0FBQyxlQUFlLENBQUMsaUJBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFFdkU7Ozs7Ozs7O09BUUc7SUFDSCxLQUFLLENBQUMsTUFBTSxDQUFDLE1BQW9CO1FBQzdCLE1BQU0sSUFBSSxDQUFDLElBQUksQ0FBQyxpQkFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FBQztJQUMvQyxDQUFDO0NBQ0o7QUFsRkQsb0NBa0ZDIn0=

package/endpoints/raw/UploadEndpoint.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.UploadEndpoint = void 0;
 const Endpoint_1 = require("../Endpoint");
@@ -36,19 +27,17 @@ class UploadEndpoint extends Endpoint_1.Endpoint {
      * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
      * @throws {@link errors!HttpError}: Other non-success status code
      */
-    uploadFrom(blob, signal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fileName = blob instanceof File ? blob.name : undefined;
-            if (this.formField) {
-                const formData = new FormData();
-                formData.set(this.formField, blob, fileName);
-                yield this.send(http_1.HttpMethod.Post, signal, undefined, formData);
-            }
-            else {
-                yield this.send(http_1.HttpMethod.Post, signal, { [http_1.HttpHeader.ContentType]: blob.type }, blob);
-            }
-        });
+    async uploadFrom(blob, signal) {
+        const fileName = blob instanceof File ? blob.name : undefined;
+        if (this.formField) {
+            const formData = new FormData();
+            formData.set(this.formField, blob, fileName);
+            await this.send(http_1.HttpMethod.Post, signal, undefined, formData);
+        }
+        else {
+            await this.send(http_1.HttpMethod.Post, signal, { [http_1.HttpHeader.ContentType]: blob.type }, blob);
+        }
     }
 }
 exports.UploadEndpoint = UploadEndpoint;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVXBsb2FkRW5kcG9pbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJVcGxvYWRFbmRwb2ludC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSwwQ0FBdUM7QUFDdkMscUNBQW9EO0FBRXBEOztHQUVHO0FBQ0gsTUFBYSxjQUFlLFNBQVEsbUJBQVE7SUFDeEM7Ozs7O09BS0c7SUFDSCxZQUFZLFFBQWtCLEVBQUUsV0FBeUIsRUFBbUIsU0FBa0I7UUFDMUYsS0FBSyxDQUFDLFFBQVEsRUFBRSxXQUFXLENBQUMsQ0FBQztRQUQyQyxjQUFTLEdBQVQsU0FBUyxDQUFTO0lBRTlGLENBQUM7SUFFRDs7Ozs7Ozs7O09BU0c7SUFDRyxVQUFVLENBQUMsSUFBaUIsRUFBRSxNQUFvQjs7WUFDcEQsTUFBTSxRQUFRLEdBQUcsSUFBSSxZQUFZLElBQUksQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDO1lBRTlELElBQUksSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO2dCQUNqQixNQUFNLFFBQVEsR0FBRyxJQUFJLFFBQVEsRUFBRSxDQUFDO2dCQUNoQyxRQUFRLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsSUFBSSxFQUFFLFFBQVEsQ0FBQyxDQUFDO2dCQUM3QyxNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsaUJBQVUsQ0FBQyxJQUFJLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxRQUFRLENBQUMsQ0FBQztZQUNsRSxDQUFDO2lCQUFNLENBQUM7Z0JBQ0osTUFBTSxJQUFJLENBQUMsSUFBSSxDQUFDLGlCQUFVLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRSxFQUFFLENBQUMsaUJBQVUsQ0FBQyxXQUFXLENBQUMsRUFBRSxJQUFJLENBQUMsSUFBSSxFQUFFLEVBQUUsSUFBSSxDQUFDLENBQUM7WUFDNUYsQ0FBQztRQUNMLENBQUM7S0FBQTtDQUNKO0FBaENELHdDQWdDQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVXBsb2FkRW5kcG9pbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJVcGxvYWRFbmRwb2ludC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwwQ0FBdUM7QUFDdkMscUNBQW9EO0FBRXBEOztHQUVHO0FBQ0gsTUFBYSxjQUFlLFNBQVEsbUJBQVE7SUFDeEM7Ozs7O09BS0c7SUFDSCxZQUFZLFFBQWtCLEVBQUUsV0FBeUIsRUFBbUIsU0FBa0I7UUFDMUYsS0FBSyxDQUFDLFFBQVEsRUFBRSxXQUFXLENBQUMsQ0FBQztRQUQyQyxjQUFTLEdBQVQsU0FBUyxDQUFTO0lBRTlGLENBQUM7SUFFRDs7Ozs7Ozs7O09BU0c7SUFDSCxLQUFLLENBQUMsVUFBVSxDQUFDLElBQWlCLEVBQUUsTUFBb0I7UUFDcEQsTUFBTSxRQUFRLEdBQUcsSUFBSSxZQUFZLElBQUksQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDO1FBRTlELElBQUksSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ2pCLE1BQU0sUUFBUSxHQUFHLElBQUksUUFBUSxFQUFFLENBQUM7WUFDaEMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFFLElBQUksRUFBRSxRQUFRLENBQUMsQ0FBQztZQUM3QyxNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsaUJBQVUsQ0FBQyxJQUFJLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxRQUFRLENBQUMsQ0FBQztRQUNsRSxDQUFDO2FBQU0sQ0FBQztZQUNKLE1BQU0sSUFBSSxDQUFDLElBQUksQ0FBQyxpQkFBVSxDQUFDLElBQUksRUFBRSxNQUFNLEVBQUUsRUFBRSxDQUFDLGlCQUFVLENBQUMsV0FBVyxDQUFDLEVBQUUsSUFBSSxDQUFDLElBQUksRUFBRSxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQzVGLENBQUM7SUFDTCxDQUFDO0NBQ0o7QUFoQ0Qsd0NBZ0NDIn0=

package/endpoints/reactive/Delay.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = delay;
+/**
+ * Waits for a specific amount of time.
+ * @param ms The time to wait in milliseconds.
+ * @param signal Used to cancel the wait.
+ * @returns `true` if the time has elapsed; `false` if the wait was cancelled via the `signal`.
+ */
+function delay(ms, signal) {
+    return new Promise(resolve => {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            resolve(false);
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timeout);
+            resolve(false);
+        };
+        const timeout = setTimeout(() => {
+            signal === null || signal === void 0 ? void 0 : signal.removeEventListener("abort", onAbort);
+            resolve(true);
+        }, ms);
+        signal === null || signal === void 0 ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGVsYXkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJEZWxheS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQU1BLHNCQW1CQztBQXpCRDs7Ozs7R0FLRztBQUNILFNBQWdCLEtBQUssQ0FBQyxFQUFVLEVBQUUsTUFBb0I7SUFDbEQsT0FBTyxJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRTtRQUN6QixJQUFJLE1BQU0sYUFBTixNQUFNLHVCQUFOLE1BQU0sQ0FBRSxPQUFPLEVBQUUsQ0FBQztZQUNsQixPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDZixPQUFPO1FBQ1gsQ0FBQztRQUVELE1BQU0sT0FBTyxHQUFHLEdBQUcsRUFBRTtZQUNqQixZQUFZLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDdEIsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ25CLENBQUMsQ0FBQztRQUVGLE1BQU0sT0FBTyxHQUFHLFVBQVUsQ0FBQyxHQUFHLEVBQUU7WUFDNUIsTUFBTSxhQUFOLE1BQU0sdUJBQU4sTUFBTSxDQUFFLG1CQUFtQixDQUFDLE9BQU8sRUFBRSxPQUFPLENBQUMsQ0FBQztZQUM5QyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDbEIsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBRVAsTUFBTSxhQUFOLE1BQU0sdUJBQU4sTUFBTSxDQUFFLGdCQUFnQixDQUFDLE9BQU8sRUFBRSxPQUFPLEVBQUUsRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUMvRCxDQUFDLENBQUMsQ0FBQztBQUNQLENBQUMifQ==

package/endpoints/reactive/Delay.ts

@@ -0,0 +1,26 @@
+/**
+ * Waits for a specific amount of time.
+ * @param ms The time to wait in milliseconds.
+ * @param signal Used to cancel the wait.
+ * @returns `true` if the time has elapsed; `false` if the wait was cancelled via the `signal`.
+ */
+export function delay(ms: number, signal?: AbortSignal): Promise<boolean> {
+    return new Promise(resolve => {
+        if (signal?.aborted) {
+            resolve(false);
+            return;
+        }
+
+        const onAbort = () => {
+            clearTimeout(timeout);
+            resolve(false);
+        };
+
+        const timeout = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve(true);
+        }, ms);
+
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}

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/GenericStreamingCollectionEndpoint.ts

@@ -0,0 +1,73 @@
+import { ElementEndpoint } from "../generic/ElementEndpoint";
+import { GenericCollectionEndpoint } from "../generic/GenericCollectionEndpoint";
+import { PartialResponse } from "../generic/PartialResponse";
+import { delay } from "./Delay";
+import { retryAfter } from "../../http";
+import { RangeNotSatisfiableError } from "../../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.
+ */
+export 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 = 3000;
+
+    /**
+     * @inheritDoc
+     */
+    protected async handle(response: Response) {
+        await super.handle(response);
+        this.pollingInterval = retryAfter(response) ?? 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: number = 0, signal?: AbortSignal): AsyncIterableIterator<TEntity> {
+        let currentStartIndex = startIndex;
+
+        while (!signal?.aborted) {
+            let response: PartialResponse<TEntity>;
+            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?.aborted) return;
+                if (!(err instanceof RangeNotSatisfiableError)) throw err;
+
+                // No new data available yet, keep polling
+                if (!await delay(this.pollingInterval, signal)) return;
+                continue;
+            }
+
+            yield* response.elements;
+            if (response.endReached) return;
+
+            // Continue polling for more data
+            if (response.range?.to === undefined) return;
+            currentStartIndex = response.range.to + 1;
+
+            if (!await delay(this.pollingInterval, signal)) return;
+        }
+    }
+
+    /**
+     * Provides a stream of `TEntity`s using {@link stream}.
+     */
+    [Symbol.asyncIterator]() { return this.stream(); }
+}