@snap/camera-kit 0.16.2 → 0.18.0

package/dist/handlers/cameraKitServiceFetchHandlerFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cameraKitServiceFetchHandlerFactory.js","sourceRoot":"","sources":["../../src/handlers/cameraKitServiceFetchHandlerFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAEvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAEhE,OAAO,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,kCAAkC,EAAE,MAAM,gCAAgC,CAAC;AAOpF,MAAM,CAAC,MAAM,mCAAmC,GAAG,UAAU,CACzD,8BAA8B,EAC9B,CAAC,kBAAkB,EAAE,0BAA0B,CAAC,KAAK,CAAU,EAC/D,CAAC,EAAE,QAAQ,EAA0B,EAAE,mBAAiC,EAAE,EAAE;IACxE,OAAO,IAAI,mBAAmB,CAAC,mBAAmB,CAAC,CAAC,GAAG,CACnD,kCAAkC,CAAC,CAAC,OAAO,EAAE,EAAE;QAC3C,OAAO,CAAC,MAAM,CAAC,0BAA0B,EAAE,qBAAqB,EAAE,CAAC,CAAC;QACpE,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,UAAU,QAAQ,EAAE,CAAC,CAAC;QACtD,OAAO,OAAO,CAAC;IACnB,CAAC,CAAC,CACL,CAAC,OAAO,CAAC;AACd,CAAC,CACJ,CAAC","sourcesContent":["import { getCameraKitUserAgent } from \"../platform/cameraKitUserAgent\";\nimport type { CameraKitConfiguration } from \"../configuration\";\nimport { configurationToken } from \"../configuration\";\nimport { Injectable } from \"../dependency-injection/Injectable\";\nimport type { FetchHandler } from \"./defaultFetchHandler\";\nimport { defaultFetchHandlerFactory } from \"./defaultFetchHandler\";\nimport { HandlerChainBuilder } from \"./HandlerChainBuilder\";\nimport { createHeadersModifyingFetchHandler } from \"./headersModifyingFetchHandler\";\n\n/**\n * A Fetch implementation which adds headers required to make authenticated calls to the CameraKit backend service.\n *\n * @internal\n */\nexport const cameraKitServiceFetchHandlerFactory = Injectable(\n    \"cameraKitServiceFetchHandler\",\n    [configurationToken, defaultFetchHandlerFactory.token] as const,\n    ({ apiToken }: CameraKitConfiguration, defaultFetchHandler: FetchHandler) => {\n        return new HandlerChainBuilder(defaultFetchHandler).map(\n            createHeadersModifyingFetchHandler((headers) => {\n                headers.append(\"x-snap-client-user-agent\", getCameraKitUserAgent());\n                headers.append(\"authorization\", `Bearer ${apiToken}`);\n                return headers;\n            })\n        ).handler;\n    }\n);\n"]}

package/dist/handlers/debugHandler.d.ts

@@ -0,0 +1,9 @@
+import type { ChainableHandler } from "./HandlerChainBuilder";
+/**
+ * Addes cookies to auth requests to custom LensCore binaries
+ * when there are debugging overrides.
+ *
+ * @returns {@link ChainableHandler}, suitable for use in {@link HandlerChainBuilder.map}
+ */
+export declare const createDebugHandler: <Res>() => ChainableHandler<RequestInfo, Res, RequestInfo, Res, RequestInit | undefined>;
+//# sourceMappingURL=debugHandler.d.ts.map

package/dist/handlers/debugHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugHandler.d.ts","sourceRoot":"","sources":["../../src/handlers/debugHandler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAG9D;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,0FAyB9B,CAAC"}

package/dist/handlers/debugHandler.js

@@ -0,0 +1,18 @@
+import { isString } from "../common/typeguards";
+import { getConfigurationOverrides } from "../configurationOverrides";
+export const createDebugHandler = () => {
+    var _a;
+    const noCustomWasmEndpoint = !((_a = getConfigurationOverrides()) === null || _a === void 0 ? void 0 : _a.wasmEndpointOverride);
+    if (noCustomWasmEndpoint) {
+        return (next) => next;
+    }
+    return (next) => (input, init) => {
+        var _a;
+        const url = isString(input) ? input : (_a = input === null || input === void 0 ? void 0 : input.url) !== null && _a !== void 0 ? _a : "";
+        if (url.startsWith("https://lens-core-wasm.sc-corp.net/")) {
+            return next(input, Object.assign(Object.assign({}, init), { credentials: "include" }));
+        }
+        return next(input, init);
+    };
+};
+//# sourceMappingURL=debugHandler.js.map

package/dist/handlers/debugHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugHandler.js","sourceRoot":"","sources":["../../src/handlers/debugHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAUtE,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAMhC,EAAE;;IACA,MAAM,oBAAoB,GAAG,CAAC,CAAA,MAAA,yBAAyB,EAAE,0CAAE,oBAAoB,CAAA,CAAC;IAEhF,IAAI,oBAAoB,EAAE;QACtB,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;KACzB;IACD,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;;QAC7B,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAA,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,GAAG,mCAAI,EAAE,CAAC;QAIvD,IAAI,GAAG,CAAC,UAAU,CAAC,qCAAqC,CAAC,EAAE;YACvD,OAAO,IAAI,CAAC,KAAK,kCACV,IAAI,KACP,WAAW,EAAE,SAAS,IACxB,CAAC;SACN;QACD,OAAO,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC7B,CAAC,CAAC;AACN,CAAC,CAAC","sourcesContent":["import { isString } from \"../common/typeguards\";\nimport { getConfigurationOverrides } from \"../configurationOverrides\";\nimport type { ChainableHandler } from \"./HandlerChainBuilder\";\nimport { HandlerChainBuilder } from \"./HandlerChainBuilder\";\n\n/**\n * Addes cookies to auth requests to custom LensCore binaries\n * when there are debugging overrides.\n *\n * @returns {@link ChainableHandler}, suitable for use in {@link HandlerChainBuilder.map}\n */\nexport const createDebugHandler = <Res>(): ChainableHandler<\n    RequestInfo,\n    Res,\n    RequestInfo,\n    Res,\n    RequestInit | undefined\n> => {\n    const noCustomWasmEndpoint = !getConfigurationOverrides()?.wasmEndpointOverride;\n\n    if (noCustomWasmEndpoint) {\n        return (next) => next;\n    }\n    return (next) => (input, init) => {\n        const url = isString(input) ? input : input?.url ?? \"\";\n        // if requests are made to internal LensCore binaries site\n        // we have to include cookies for auth purposes\n        // as per https://wiki.sc-corp.net/x/KsnRCg\n        if (url.startsWith(\"https://lens-core-wasm.sc-corp.net/\")) {\n            return next(input, {\n                ...init,\n                credentials: \"include\",\n            });\n        }\n        return next(input, init);\n    };\n};\n"]}

package/dist/handlers/defaultFetchHandler.d.ts

@@ -0,0 +1,16 @@
+export type FetchHandler<R = Response> = (input: RequestInfo, init?: RequestInit) => Promise<R>;
+/**
+ * The default Fetch implementation, used to make a simple HTTP requests without any custom headers. This can be passed
+ * to `HandlerChainBuilder` to form the basis for other Fetch implementations (e.g. with custom headers, which extract
+ * the Response body, etc.)
+ *
+ * Has support for retries, client-side timeout, and navigating federated auth flows that may not support CORs requests.
+ *
+ * @internal
+ */
+export declare const defaultFetchHandlerFactory: {
+    (): FetchHandler<Response>;
+    token: "defaultFetchHandler";
+    dependencies: [];
+};
+//# sourceMappingURL=defaultFetchHandler.d.ts.map

package/dist/handlers/defaultFetchHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultFetchHandler.d.ts","sourceRoot":"","sources":["../../src/handlers/defaultFetchHandler.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,YAAY,CAAC,CAAC,GAAG,QAAQ,IAAI,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;AAEhG;;;;;;;;GAQG;AAEH,eAAO,MAAM,0BAA0B;;;;CAuBrC,CAAC"}

package/dist/handlers/defaultFetchHandler.js

@@ -0,0 +1,25 @@
+import { Injectable } from "../dependency-injection/Injectable";
+import { createDebugHandler } from "./debugHandler";
+import { HandlerChainBuilder } from "./HandlerChainBuilder";
+import { createNoCorsRetryingFetchHandler } from "./noCorsRetryingFetchHandler";
+import { createRetryingHandler } from "./retryingHandler";
+import { createTimeoutHandler } from "./timeoutHandler";
+export const defaultFetchHandlerFactory = Injectable("defaultFetchHandler", () => {
+    return (new HandlerChainBuilder(fetch)
+        .map(createDebugHandler())
+        .map(createTimeoutHandler({ timeout: 20 * 1000 }))
+        .map(createNoCorsRetryingFetchHandler())
+        .map(createRetryingHandler({
+        maxRetries: 3,
+        retryPredicate: (responseOrError) => {
+            if (responseOrError instanceof Response) {
+                if (responseOrError.ok)
+                    return false;
+                if (responseOrError.status % 400 < 100)
+                    return false;
+            }
+            return true;
+        },
+    })).handler);
+});
+//# sourceMappingURL=defaultFetchHandler.js.map

package/dist/handlers/defaultFetchHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultFetchHandler.js","sourceRoot":"","sources":["../../src/handlers/defaultFetchHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,gCAAgC,EAAE,MAAM,8BAA8B,CAAC;AAChF,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAcxD,MAAM,CAAC,MAAM,0BAA0B,GAAG,UAAU,CAAC,qBAAqB,EAAE,GAAiB,EAAE;IAC3F,OAAO,CACH,IAAI,mBAAmB,CAAC,KAAK,CAAC;SACzB,GAAG,CAAC,kBAAkB,EAAE,CAAC;SAGzB,GAAG,CAAC,oBAAoB,CAAC,EAAE,OAAO,EAAE,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC;SACjD,GAAG,CAAC,gCAAgC,EAAE,CAAC;SACvC,GAAG,CACA,qBAAqB,CAAC;QAClB,UAAU,EAAE,CAAC;QACb,cAAc,EAAE,CAAC,eAAe,EAAE,EAAE;YAGhC,IAAI,eAAe,YAAY,QAAQ,EAAE;gBACrC,IAAI,eAAe,CAAC,EAAE;oBAAE,OAAO,KAAK,CAAC;gBACrC,IAAI,eAAe,CAAC,MAAM,GAAG,GAAG,GAAG,GAAG;oBAAE,OAAO,KAAK,CAAC;aACxD;YACD,OAAO,IAAI,CAAC;QAChB,CAAC;KACJ,CAAC,CACL,CAAC,OAAO,CAChB,CAAC;AACN,CAAC,CAAC,CAAC","sourcesContent":["import { Injectable } from \"../dependency-injection/Injectable\";\nimport { createDebugHandler } from \"./debugHandler\";\nimport { HandlerChainBuilder } from \"./HandlerChainBuilder\";\nimport { createNoCorsRetryingFetchHandler } from \"./noCorsRetryingFetchHandler\";\nimport { createRetryingHandler } from \"./retryingHandler\";\nimport { createTimeoutHandler } from \"./timeoutHandler\";\n\nexport type FetchHandler<R = Response> = (input: RequestInfo, init?: RequestInit) => Promise<R>;\n\n/**\n * The default Fetch implementation, used to make a simple HTTP requests without any custom headers. This can be passed\n * to `HandlerChainBuilder` to form the basis for other Fetch implementations (e.g. with custom headers, which extract\n * the Response body, etc.)\n *\n * Has support for retries, client-side timeout, and navigating federated auth flows that may not support CORs requests.\n *\n * @internal\n */\n\nexport const defaultFetchHandlerFactory = Injectable(\"defaultFetchHandler\", (): FetchHandler => {\n    return (\n        new HandlerChainBuilder(fetch)\n            .map(createDebugHandler())\n            // The 20-second per-request timeout is pretty arbitrary, it's just set to be longer than our API gateway\n            // timeout (15s) and lower than the browsers own timeout (variable, Chrome's is 5m).\n            .map(createTimeoutHandler({ timeout: 20 * 1000 }))\n            .map(createNoCorsRetryingFetchHandler())\n            .map(\n                createRetryingHandler({\n                    maxRetries: 3,\n                    retryPredicate: (responseOrError) => {\n                        // Don't retry successful Responses or Responses with a 4xx HTTP status code (indicating a\n                        // client error). Do retry all 5xx HTTP status codes.\n                        if (responseOrError instanceof Response) {\n                            if (responseOrError.ok) return false;\n                            if (responseOrError.status % 400 < 100) return false;\n                        }\n                        return true;\n                    },\n                })\n            ).handler\n    );\n});\n"]}

package/dist/handlers/headersModifyingFetchHandler.d.ts

@@ -0,0 +1,9 @@
+import type { ChainableHandler } from "./HandlerChainBuilder";
+/**
+ * Modify a Fetch Request's headers.
+ *
+ * @param modifyHeaders
+ * @returns {@link ChainableHandler}, suitable for use in {@link HandlerChainBuilder.map}
+ */
+export declare const createHeadersModifyingFetchHandler: <Res>(modifyHeaders: (headers: Headers) => Headers) => ChainableHandler<RequestInfo, Res, RequestInfo, Res, RequestInit | undefined>;
+//# sourceMappingURL=headersModifyingFetchHandler.d.ts.map

package/dist/handlers/headersModifyingFetchHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headersModifyingFetchHandler.d.ts","sourceRoot":"","sources":["../../src/handlers/headersModifyingFetchHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D;;;;;GAKG;AACH,eAAO,MAAM,kCAAkC,iCAEd,OAAO,KAAK,OAAO,kFAe/C,CAAC"}

package/dist/handlers/headersModifyingFetchHandler.js

@@ -0,0 +1,10 @@
+export const createHeadersModifyingFetchHandler = (modifyHeaders) => (next) => (input, init) => {
+    const headers = init && init.headers
+        ? new Headers(init.headers)
+        : typeof input === "string"
+            ? new Headers()
+            : input.headers;
+    const modifiedHeaders = modifyHeaders(headers);
+    return next(input, Object.assign(Object.assign({}, init), { headers: modifiedHeaders }));
+};
+//# sourceMappingURL=headersModifyingFetchHandler.js.map

package/dist/handlers/headersModifyingFetchHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"headersModifyingFetchHandler.js","sourceRoot":"","sources":["../../src/handlers/headersModifyingFetchHandler.ts"],"names":[],"mappings":"AAQA,MAAM,CAAC,MAAM,kCAAkC,GAC3C,CACI,aAA4C,EACiC,EAAE,CACnF,CAAC,IAAI,EAAE,EAAE,CACT,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;IACZ,MAAM,OAAO,GACT,IAAI,IAAI,IAAI,CAAC,OAAO;QAChB,CAAC,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC;QAC3B,CAAC,CAAC,OAAO,KAAK,KAAK,QAAQ;YAC3B,CAAC,CAAC,IAAI,OAAO,EAAE;YACf,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC;IAExB,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;IAG/C,OAAO,IAAI,CAAC,KAAK,kCAAO,IAAI,KAAE,OAAO,EAAE,eAAe,IAAG,CAAC;AAC9D,CAAC,CAAC","sourcesContent":["import type { ChainableHandler } from \"./HandlerChainBuilder\";\n\n/**\n * Modify a Fetch Request's headers.\n *\n * @param modifyHeaders\n * @returns {@link ChainableHandler}, suitable for use in {@link HandlerChainBuilder.map}\n */\nexport const createHeadersModifyingFetchHandler =\n    <Res>(\n        modifyHeaders: (headers: Headers) => Headers\n    ): ChainableHandler<RequestInfo, Res, RequestInfo, Res, RequestInit | undefined> =>\n    (next) =>\n    (input, init) => {\n        const headers =\n            init && init.headers\n                ? new Headers(init.headers)\n                : typeof input === \"string\"\n                ? new Headers()\n                : input.headers;\n\n        const modifiedHeaders = modifyHeaders(headers);\n\n        // When `init` contains headers, `fetch` uses these *instead* of any headers found in the `input` Request.\n        return next(input, { ...init, headers: modifiedHeaders });\n    };\n"]}

package/dist/handlers/mappingHandler.d.ts

@@ -0,0 +1,20 @@
+import type { PageVisibility } from "../common/pageVisibility";
+import type { ChainableHandler, RequestMetadata } from "./HandlerChainBuilder";
+/**
+ * Map from one request type to another, potentially asynchronously.
+ *
+ * **NOTE:** If `maxMapConcurrency` is set to some finite number, and more requests are handled than are allowed to
+ * be concurrently mapped, the waiting requests will be placed into a unbounded buffer. If, for example, requests are
+ * handled with high frequency, `maxMapConcurrency` is low, and the `map` function returns a long-running Promise, this
+ * buffer could use a large amount of memory. Keep this in mind when using this handler.
+ *
+ * @param map Transform each request, may be sync or async.
+ * @param pageVisibility Determines whether to flush buffered requests when the page becomes hidden.
+ * `false` value indicates that page visibility handling is avoided, while
+ * a {@link PageVisibility} instance is used to subscribe to page visibility change events.
+ * @param maxMapConcurrency If the `map` function is async, it will be invoked at most this number of times
+ * concurrently. Setting this to 1 could be useful if it's important for `map` to be called in serial.
+ * @returns {@link ChainableHandler}, suitable for use in {@link HandlerChainBuilder.map}
+ */
+export declare const createMappingHandler: <Req, MappedReq, Res, Meta extends RequestMetadata>(map: (request: Req) => MappedReq | Promise<MappedReq>, pageVisibility: PageVisibility | false, maxMapConcurrency?: number) => ChainableHandler<Req, Res, MappedReq, Res, Meta>;
+//# sourceMappingURL=mappingHandler.d.ts.map

package/dist/handlers/mappingHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mappingHandler.d.ts","sourceRoot":"","sources":["../../src/handlers/mappingHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,gBAAgB,EAAW,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAQxF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB,6HAEb,cAAc,GAAG,KAAK,sBACnB,MAAM,qDA6C5B,CAAC"}

package/dist/handlers/mappingHandler.js

@@ -0,0 +1,44 @@
+import { __awaiter } from "tslib";
+export const createMappingHandler = (map, pageVisibility, maxMapConcurrency = Number.POSITIVE_INFINITY) => {
+    const buffer = [];
+    let mapConcurrency = 0;
+    const processRequest = (request) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            mapConcurrency++;
+            const mapped = request.map();
+            if (mapped instanceof Promise)
+                request.next(yield mapped);
+            else if (mapped)
+                request.next(mapped);
+        }
+        catch (error) {
+            request.reject(error);
+        }
+        finally {
+            mapConcurrency--;
+        }
+        while (buffer.length > 0 && mapConcurrency < maxMapConcurrency) {
+            processRequest(buffer.shift());
+        }
+    });
+    if (pageVisibility) {
+        pageVisibility.onPageHidden(() => {
+            while (buffer.length > 0)
+                processRequest(buffer.shift());
+        });
+    }
+    return (next) => (request, metadata) => {
+        return new Promise((resolve, reject) => {
+            const mappableRequest = {
+                map: () => map(request),
+                next: (mappedRequest) => next(mappedRequest, metadata).then(resolve).catch(reject),
+                reject,
+            };
+            if (mapConcurrency < maxMapConcurrency)
+                processRequest(mappableRequest);
+            else
+                buffer.push(mappableRequest);
+        });
+    };
+};
+//# sourceMappingURL=mappingHandler.js.map

package/dist/handlers/mappingHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mappingHandler.js","sourceRoot":"","sources":["../../src/handlers/mappingHandler.ts"],"names":[],"mappings":";AAyBA,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAChC,GAAqD,EACrD,cAAsC,EACtC,oBAA4B,MAAM,CAAC,iBAAiB,EACJ,EAAE;IAClD,MAAM,MAAM,GAAiC,EAAE,CAAC;IAChD,IAAI,cAAc,GAAG,CAAC,CAAC;IAEvB,MAAM,cAAc,GAAG,CAAO,OAAmC,EAAE,EAAE;QACjE,IAAI;YACA,cAAc,EAAE,CAAC;YACjB,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;YAK7B,IAAI,MAAM,YAAY,OAAO;gBAAE,OAAO,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,CAAC;iBACrD,IAAI,MAAM;gBAAE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SACzC;QAAC,OAAO,KAAK,EAAE;YACZ,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;SACzB;gBAAS;YACN,cAAc,EAAE,CAAC;SACpB;QACD,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,cAAc,GAAG,iBAAiB,EAAE;YAE5D,cAAc,CAAC,MAAM,CAAC,KAAK,EAAG,CAAC,CAAC;SACnC;IACL,CAAC,CAAA,CAAC;IAIF,IAAI,cAAc,EAAE;QAChB,cAAc,CAAC,YAAY,CAAC,GAAG,EAAE;YAC7B,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC;gBAAE,cAAc,CAAC,MAAM,CAAC,KAAK,EAAG,CAAC,CAAC;QAC9D,CAAC,CAAC,CAAC;KACN;IAED,OAAO,CAAC,IAAmC,EAAE,EAAE,CAAC,CAAC,OAAY,EAAE,QAAe,EAAE,EAAE;QAC9E,OAAO,IAAI,OAAO,CAAM,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACxC,MAAM,eAAe,GAA+B;gBAChD,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC;gBACvB,IAAI,EAAE,CAAC,aAAa,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC;gBAClF,MAAM;aACT,CAAC;YACF,IAAI,cAAc,GAAG,iBAAiB;gBAAE,cAAc,CAAC,eAAe,CAAC,CAAC;;gBACnE,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;IACP,CAAC,CAAC;AACN,CAAC,CAAC","sourcesContent":["import type { PageVisibility } from \"../common/pageVisibility\";\nimport type { ChainableHandler, Handler, RequestMetadata } from \"./HandlerChainBuilder\";\n\ninterface MappableRequest<T> {\n    map: () => T | Promise<T>;\n    next: (request: T) => Promise<void>;\n    reject: (reason: unknown) => void;\n}\n\n/**\n * Map from one request type to another, potentially asynchronously.\n *\n * **NOTE:** If `maxMapConcurrency` is set to some finite number, and more requests are handled than are allowed to\n * be concurrently mapped, the waiting requests will be placed into a unbounded buffer. If, for example, requests are\n * handled with high frequency, `maxMapConcurrency` is low, and the `map` function returns a long-running Promise, this\n * buffer could use a large amount of memory. Keep this in mind when using this handler.\n *\n * @param map Transform each request, may be sync or async.\n * @param pageVisibility Determines whether to flush buffered requests when the page becomes hidden.\n * `false` value indicates that page visibility handling is avoided, while\n * a {@link PageVisibility} instance is used to subscribe to page visibility change events.\n * @param maxMapConcurrency If the `map` function is async, it will be invoked at most this number of times\n * concurrently. Setting this to 1 could be useful if it's important for `map` to be called in serial.\n * @returns {@link ChainableHandler}, suitable for use in {@link HandlerChainBuilder.map}\n */\nexport const createMappingHandler = <Req, MappedReq, Res, Meta extends RequestMetadata>(\n    map: (request: Req) => MappedReq | Promise<MappedReq>,\n    pageVisibility: PageVisibility | false,\n    maxMapConcurrency: number = Number.POSITIVE_INFINITY\n): ChainableHandler<Req, Res, MappedReq, Res, Meta> => {\n    const buffer: MappableRequest<MappedReq>[] = [];\n    let mapConcurrency = 0;\n\n    const processRequest = async (request: MappableRequest<MappedReq>) => {\n        try {\n            mapConcurrency++;\n            const mapped = request.map();\n            // We want to make sure that if the mapping operation is not async, we don't introduce asynchronicity here\n            // (which unfortunately happens even if you `await` a non-Promise value). This is important so that e.g.\n            // handlers which run when the page is terminated can send requests synchronously, since the browser may\n            // not pick up any async handlers registered to run on the following event loop.\n            if (mapped instanceof Promise) request.next(await mapped);\n            else if (mapped) request.next(mapped);\n        } catch (error) {\n            request.reject(error);\n        } finally {\n            mapConcurrency--;\n        }\n        while (buffer.length > 0 && mapConcurrency < maxMapConcurrency) {\n            // Safety: we just checked for `buffer.length > 0`, so the shifted value will never be undefined.\n            processRequest(buffer.shift()!);\n        }\n    };\n\n    // This may indicate that the page is being unloaded, in which case we may want to flush any buffered requests\n    // regardless of our max concurrency – otherwise those requests will be lost when the page terminates.\n    if (pageVisibility) {\n        pageVisibility.onPageHidden(() => {\n            while (buffer.length > 0) processRequest(buffer.shift()!);\n        });\n    }\n\n    return (next: Handler<MappedReq, Res, Meta>) => (request: Req, metadata?: Meta) => {\n        return new Promise<Res>((resolve, reject) => {\n            const mappableRequest: MappableRequest<MappedReq> = {\n                map: () => map(request),\n                next: (mappedRequest) => next(mappedRequest, metadata).then(resolve).catch(reject),\n                reject,\n            };\n            if (mapConcurrency < maxMapConcurrency) processRequest(mappableRequest);\n            else buffer.push(mappableRequest);\n        });\n    };\n};\n"]}

package/dist/handlers/noCorsRetryingFetchHandler.d.ts

@@ -0,0 +1,49 @@
+import type { ChainableHandler } from "./HandlerChainBuilder";
+/**
+ * Some requests may require a no-cors pre-flight (which are allowed to follow redirects) before they can be
+ * successful.
+ *
+ * An example is a federated identity authentication flow, like OpenID Connect or OAuth. In many such schemes,
+ * an unauthenticated request will not include CORs headers. Instead, a redirect to an Identity Provider will be
+ * returned. In order follow this redirect, the Fetch request must be made with "no-cors" mode.
+ *
+ * Once the "no-cors" request is made, redirects are followed resulting in authentication cookies being set on the
+ * original domain. Then, the original request can be retried and the server will authenticate the request and set
+ * proper CORs headers on the response.
+ *
+ * Here's an example request flow, in which the page already has cookies for IdentityProvider.com (if that wasn't
+ * the case, IdentityProvider.com would prompt the user for credentials and the rest of the flow would be the same):
+ *
+ * ```
+ * WebPage a.com        MyServer b.com    IdentityProvider c.com
+ *    |                         |                 |
+ * Original request,            |                 |
+ * unauthenticated:             |                 |
+ *    |------------------------>|                 |
+ *    |<--302: c.com, no CORs---|                 |
+ *    |                         |                 |
+ *    |                         |                 |
+ * No CORs headers in           |                 |
+ * response. Retry in           |                 |
+ * "no-cors" mode:              |                 |
+ *    |-----"no-cors" mode----->|                 |
+ *    |<--302: c.com, no CORs---|                 |
+ *    |                         |                 |
+ *    |                         |                 |
+ *    |------------------IdP cookies------------->|
+ *    |<----------302: b.com?token=foo------------|
+ *                              |                 |
+ *    |                         |                 |
+ *    |----b.com?token=foo----->|                 |
+ *    |<-302: b.com, set cookie-|                 |
+ *    |                         |                 |
+ *    |                         |                 |
+ * Retry original request,      |                 |
+ * now authenticated:           |                 |
+ *    |-----------cookie------->|                 |
+ *    |<-----------200----------|                 |
+ *                              |                 |
+ * ```
+ */
+export declare const createNoCorsRetryingFetchHandler: <Res>() => ChainableHandler<RequestInfo, Res, RequestInfo, Res, RequestInit | undefined>;
+//# sourceMappingURL=noCorsRetryingFetchHandler.d.ts.map

package/dist/handlers/noCorsRetryingFetchHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noCorsRetryingFetchHandler.d.ts","sourceRoot":"","sources":["../../src/handlers/noCorsRetryingFetchHandler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAS9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,gCAAgC,0FA+C5C,CAAC"}

package/dist/handlers/noCorsRetryingFetchHandler.js

@@ -0,0 +1,33 @@
+import { __awaiter } from "tslib";
+import { getLogger } from "../logger/logger";
+import { ensureClonedRequest } from "./retryingHandler";
+const logger = getLogger("noCorsRetryingFetchHandler");
+const logRetry = (error) => {
+    logger.warn(`NoCorsRetrying handler got failed response:`, error, `Retrying request with {mode: "no-cors"}.`);
+};
+export const createNoCorsRetryingFetchHandler = () => {
+    const noCorsRequests = new Map();
+    return (next) => (input, init = {}) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        let requestKey = typeof input === "string" ? input : input.url;
+        try {
+            requestKey = new URL(requestKey, location.origin).host;
+        }
+        catch (_) {
+        }
+        try {
+            return yield next(ensureClonedRequest(input), init);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError")
+                throw error;
+            logRetry(error);
+            const noCorsRequest = (_a = noCorsRequests.get(requestKey)) !== null && _a !== void 0 ? _a : next(ensureClonedRequest(input), Object.assign(Object.assign({}, init), { mode: "no-cors" }));
+            noCorsRequests.set(requestKey, noCorsRequest);
+            yield noCorsRequest;
+            noCorsRequests.delete(requestKey);
+            return next(ensureClonedRequest(input), init);
+        }
+    });
+};
+//# sourceMappingURL=noCorsRetryingFetchHandler.js.map

package/dist/handlers/noCorsRetryingFetchHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noCorsRetryingFetchHandler.js","sourceRoot":"","sources":["../../src/handlers/noCorsRetryingFetchHandler.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,MAAM,MAAM,GAAG,SAAS,CAAC,4BAA4B,CAAC,CAAC;AAEvD,MAAM,QAAQ,GAAG,CAAC,KAAU,EAAE,EAAE;IAC5B,MAAM,CAAC,IAAI,CAAC,6CAA6C,EAAE,KAAK,EAAE,0CAA0C,CAAC,CAAC;AAClH,CAAC,CAAC;AAgDF,MAAM,CAAC,MAAM,gCAAgC,GAAG,GAM9C,EAAE;IAIA,MAAM,cAAc,GAAG,IAAI,GAAG,EAAwB,CAAC;IAEvD,OAAO,CAAC,IAAI,EAAE,EAAE,CACZ,CAAO,KAAK,EAAE,IAAI,GAAG,EAAE,EAAE,EAAE;;QAIvB,IAAI,UAAU,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC;QAC/D,IAAI;YACA,UAAU,GAAG,IAAI,GAAG,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC;SAC1D;QAAC,OAAO,CAAC,EAAE;SAEX;QAED,IAAI;YAKA,OAAO,MAAM,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC;SACvD;QAAC,OAAO,KAAK,EAAE;YAEZ,IAAI,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY;gBAAE,MAAM,KAAK,CAAC;YAMvE,QAAQ,CAAC,KAAK,CAAC,CAAC;YAChB,MAAM,aAAa,GACf,MAAA,cAAc,CAAC,GAAG,CAAC,UAAU,CAAC,mCAAI,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,kCAAO,IAAI,KAAE,IAAI,EAAE,SAAS,IAAG,CAAC;YACrG,cAAc,CAAC,GAAG,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC;YAC9C,MAAM,aAAa,CAAC;YACpB,cAAc,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;YAClC,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC;SACjD;IACL,CAAC,CAAA,CAAC;AACV,CAAC,CAAC","sourcesContent":["import { getLogger } from \"../logger/logger\";\nimport type { ChainableHandler } from \"./HandlerChainBuilder\";\nimport { ensureClonedRequest } from \"./retryingHandler\";\n\nconst logger = getLogger(\"noCorsRetryingFetchHandler\");\n\nconst logRetry = (error: any) => {\n    logger.warn(`NoCorsRetrying handler got failed response:`, error, `Retrying request with {mode: \"no-cors\"}.`);\n};\n\n/**\n * Some requests may require a no-cors pre-flight (which are allowed to follow redirects) before they can be\n * successful.\n *\n * An example is a federated identity authentication flow, like OpenID Connect or OAuth. In many such schemes,\n * an unauthenticated request will not include CORs headers. Instead, a redirect to an Identity Provider will be\n * returned. In order follow this redirect, the Fetch request must be made with \"no-cors\" mode.\n *\n * Once the \"no-cors\" request is made, redirects are followed resulting in authentication cookies being set on the\n * original domain. Then, the original request can be retried and the server will authenticate the request and set\n * proper CORs headers on the response.\n *\n * Here's an example request flow, in which the page already has cookies for IdentityProvider.com (if that wasn't\n * the case, IdentityProvider.com would prompt the user for credentials and the rest of the flow would be the same):\n *\n * ```\n * WebPage a.com        MyServer b.com    IdentityProvider c.com\n *    |                         |                 |\n * Original request,            |                 |\n * unauthenticated:             |                 |\n *    |------------------------>|                 |\n *    |<--302: c.com, no CORs---|                 |\n *    |                         |                 |\n *    |                         |                 |\n * No CORs headers in           |                 |\n * response. Retry in           |                 |\n * \"no-cors\" mode:              |                 |\n *    |-----\"no-cors\" mode----->|                 |\n *    |<--302: c.com, no CORs---|                 |\n *    |                         |                 |\n *    |                         |                 |\n *    |------------------IdP cookies------------->|\n *    |<----------302: b.com?token=foo------------|\n *                              |                 |\n *    |                         |                 |\n *    |----b.com?token=foo----->|                 |\n *    |<-302: b.com, set cookie-|                 |\n *    |                         |                 |\n *    |                         |                 |\n * Retry original request,      |                 |\n * now authenticated:           |                 |\n *    |-----------cookie------->|                 |\n *    |<-----------200----------|                 |\n *                              |                 |\n * ```\n */\nexport const createNoCorsRetryingFetchHandler = <Res>(): ChainableHandler<\n    RequestInfo,\n    Res,\n    RequestInfo,\n    Res,\n    RequestInit | undefined\n> => {\n    // If concurrent requests are made to the same domain, we only want to perform one \"no-cors\" request. We assume\n    // requests to the same domain will set the same authentication cookies. To support this, we'll store any\n    // in-flight \"no-cors\" retries and re-use them for concurrent requests.\n    const noCorsRequests = new Map<string, Promise<Res>>();\n\n    return (next) =>\n        async (input, init = {}) => {\n            // `host` includes domain:port, so works for local development. If the input is a relative path, we'll\n            // use `location.origin` to resolve into a fully qualified URL (although of course we don't actually\n            // anticipate any CORs issues in that case -- but this is cleaner than special-casing).\n            let requestKey = typeof input === \"string\" ? input : input.url;\n            try {\n                requestKey = new URL(requestKey, location.origin).host;\n            } catch (_) {\n                /* no-op, use the full input URL as the requestKey */\n            }\n\n            try {\n                // By always attempting the request first, we avoid needing to maintain any state about the validity\n                // of the request (e.g. the expiration time for a credential). We just make the request, and if it\n                // fails, this tells us we've made an invalid request. This does result in one additional request, but\n                // it makes this much more flexible and avoids having to maintain state (which can be a source of bugs).\n                return await next(ensureClonedRequest(input), init);\n            } catch (error) {\n                // If the request fails because it was aborted, we assume this was done intentionally and we can stop.\n                if (error instanceof Error && error.name === \"AbortError\") throw error;\n\n                // Otherwise we don't actually care what error occurred – we know this will be an error thrown by\n                // `fetch` itself (rather than some error encountered on the server, which wouldn't cause `next` to\n                // throw), and we'll just assume it's a CORs error. If it's not, we'll perform a \"no-cors\" retry anyway,\n                // which will presumably also fail, and that failure will be returned to the caller.\n                logRetry(error);\n                const noCorsRequest =\n                    noCorsRequests.get(requestKey) ?? next(ensureClonedRequest(input), { ...init, mode: \"no-cors\" });\n                noCorsRequests.set(requestKey, noCorsRequest);\n                await noCorsRequest;\n                noCorsRequests.delete(requestKey);\n                return next(ensureClonedRequest(input), init);\n            }\n        };\n};\n"]}

package/dist/handlers/persistingHandler.d.ts

@@ -0,0 +1,15 @@
+import type { Persistence } from "../persistence/Persistence";
+import type { ChainableHandler, RequestMetadata } from "./HandlerChainBuilder";
+/**
+ * This handler persists in-flight requests locally, so that if there is an unexpected termination of the process (e.g.
+ * the browser tab crashes or is closed) those requests can be recovered and retried on the next page load.
+ *
+ * Keep in mind, using this handler means some *successful* requests may be repeated (e.g. if the request made it to a
+ * server, which responded, but the response didn't reach the browser before the tab closed). Any handler chain making
+ * use of this handler should only handle idempotent requests.
+ *
+ * @param persistence Requests will be temporarily stored here while they are in-flight.
+ * @returns {@link ChainableHandler}, suitable for use in {@link HandlerChainBuilder.map}
+ */
+export declare const createPersistingHandler: <Req, Res, Meta extends RequestMetadata>(persistence: Persistence<[Req, Meta | undefined]>) => ChainableHandler<Req, Res, Req, Res, Meta>;
+//# sourceMappingURL=persistingHandler.d.ts.map

package/dist/handlers/persistingHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistingHandler.d.ts","sourceRoot":"","sources":["../../src/handlers/persistingHandler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAW,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAIxF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,2IAyDnC,CAAC"}

package/dist/handlers/persistingHandler.js

@@ -0,0 +1,43 @@
+import { __awaiter } from "tslib";
+import { getLogger } from "../logger/logger";
+const logger = getLogger("persistingHandler");
+export const createPersistingHandler = (persistence) => {
+    let needsRecovery = true;
+    const maybePerformRecovery = (next) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!needsRecovery)
+            return;
+        needsRecovery = false;
+        try {
+            const requests = yield persistence.removeAll();
+            if (requests.length === 0)
+                return;
+            requests.forEach(([request, metadata]) => performRequest(next)(request, metadata).catch((error) => {
+                logger.error(error);
+            }));
+        }
+        catch (error) {
+            logger.error(error);
+        }
+    });
+    const performRequest = (next) => (req, metadata) => __awaiter(void 0, void 0, void 0, function* () {
+        maybePerformRecovery(next);
+        const keyPromise = persistence.store([req, metadata]).catch((error) => {
+            logger.error(error);
+            return null;
+        });
+        try {
+            return yield next(req, metadata);
+        }
+        finally {
+            keyPromise
+                .then((key) => {
+                if (key !== null)
+                    return persistence.remove(key);
+                return;
+            })
+                .catch((error) => logger.error(error));
+        }
+    });
+    return performRequest;
+};
+//# sourceMappingURL=persistingHandler.js.map

package/dist/handlers/persistingHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistingHandler.js","sourceRoot":"","sources":["../../src/handlers/persistingHandler.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAI7C,MAAM,MAAM,GAAG,SAAS,CAAC,mBAAmB,CAAC,CAAC;AAa9C,MAAM,CAAC,MAAM,uBAAuB,GAAG,CACnC,WAAiD,EACP,EAAE;IAC5C,IAAI,aAAa,GAAG,IAAI,CAAC;IACzB,MAAM,oBAAoB,GAAG,CAAO,IAA6B,EAAE,EAAE;QACjE,IAAI,CAAC,aAAa;YAAE,OAAO;QAC3B,aAAa,GAAG,KAAK,CAAC;QACtB,IAAI;YACA,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC,SAAS,EAAE,CAAC;YAC/C,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO;YAGlC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,EAAE,CACrC,cAAc,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;gBACpD,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACxB,CAAC,CAAC,CACL,CAAC;SAIL;QAAC,OAAO,KAAK,EAAE;YAGZ,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;SACvB;IACL,CAAC,CAAA,CAAC;IAEF,MAAM,cAAc,GAAG,CAAC,IAA6B,EAAE,EAAE,CAAC,CAAO,GAAQ,EAAE,QAAe,EAAE,EAAE;QAG1F,oBAAoB,CAAC,IAAI,CAAC,CAAC;QAM3B,MAAM,UAAU,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YAClE,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACpB,OAAO,IAAI,CAAC;QAChB,CAAC,CAAC,CAAC;QACH,IAAI;YACA,OAAO,MAAM,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;SACpC;gBAAS;YAGN,UAAU;iBACL,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE;gBACV,IAAI,GAAG,KAAK,IAAI;oBAAE,OAAO,WAAW,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBACjD,OAAO;YACX,CAAC,CAAC;iBAID,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;SAC9C;IACL,CAAC,CAAA,CAAC;IACF,OAAO,cAAc,CAAC;AAC1B,CAAC,CAAC","sourcesContent":["import { getLogger } from \"../logger/logger\";\nimport type { Persistence } from \"../persistence/Persistence\";\nimport type { ChainableHandler, Handler, RequestMetadata } from \"./HandlerChainBuilder\";\n\nconst logger = getLogger(\"persistingHandler\");\n\n/**\n * This handler persists in-flight requests locally, so that if there is an unexpected termination of the process (e.g.\n * the browser tab crashes or is closed) those requests can be recovered and retried on the next page load.\n *\n * Keep in mind, using this handler means some *successful* requests may be repeated (e.g. if the request made it to a\n * server, which responded, but the response didn't reach the browser before the tab closed). Any handler chain making\n * use of this handler should only handle idempotent requests.\n *\n * @param persistence Requests will be temporarily stored here while they are in-flight.\n * @returns {@link ChainableHandler}, suitable for use in {@link HandlerChainBuilder.map}\n */\nexport const createPersistingHandler = <Req, Res, Meta extends RequestMetadata>(\n    persistence: Persistence<[Req, Meta | undefined]>\n): ChainableHandler<Req, Res, Req, Res, Meta> => {\n    let needsRecovery = true;\n    const maybePerformRecovery = async (next: Handler<Req, Res, Meta>) => {\n        if (!needsRecovery) return;\n        needsRecovery = false;\n        try {\n            const requests = await persistence.removeAll();\n            if (requests.length === 0) return;\n            // If a recovered request fails, we'll report the error and prevent it from disrupting other requests. We\n            // won't re-persist to avoid a poison-pill request that remains in storage forever.\n            requests.forEach(([request, metadata]) =>\n                performRequest(next)(request, metadata).catch((error) => {\n                    logger.error(error);\n                })\n            );\n\n            // If we fail to retrieve, we have no option but to report the error and proceed. Since we can't tell here\n            // if there were any requests to recover, we cannot say if an error here will actually result in data loss.\n        } catch (error) {\n            // TODO: we will also want to report persistence size (either here or elsewhere) to detect scenarious that\n            // could result in unbounded DB growth.\n            logger.error(error);\n        }\n    };\n\n    const performRequest = (next: Handler<Req, Res, Meta>) => async (req: Req, metadata?: Meta) => {\n        // If there are requests to be recovered (e.g. a prior session crashed while requests were in-flight), they will\n        // be passed to the next handler in the chain. This will happen at most once per page load.\n        maybePerformRecovery(next);\n\n        // Whether the persistence succeeds or fails, we always want to make the request – so we don't need to wait for\n        // the request to be stored before passing it to the `next` handler. This is why we're not awaiting the store\n        // call here. We'll also swallow any errors, simply returning `null` for the key – persistence and recovery are\n        // always best-effort, and failure should not disrupt other application behavior.\n        const keyPromise = persistence.store([req, metadata]).catch((error) => {\n            logger.error(error);\n            return null;\n        });\n        try {\n            return await next(req, metadata);\n        } finally {\n            // We don't care if the request was successful or not, either way once it is completed we will remove\n            // the request from the persistent store.\n            keyPromise\n                .then((key) => {\n                    if (key !== null) return persistence.remove(key);\n                    return;\n                })\n                // If removal fails, we will recover and re-send the request – failure could occur if the OS cannot\n                // complete the DB transaction (e.g. power loss), or potentially in other exceptional scenarios.\n                // Therefore it's important that requests handled by this handler be idempotent.\n                .catch((error) => logger.error(error));\n        }\n    };\n    return performRequest;\n};\n"]}

package/dist/handlers/rateLimitingHandler.d.ts

@@ -0,0 +1,25 @@
+import type { PageVisibility } from "../common/pageVisibility";
+import type { ChainableHandler, RequestMetadata } from "./HandlerChainBuilder";
+/**
+ * Limit the rate at which requests are passed to the next handler in the chain.
+ *
+ * During any page transitions to "hidden" – possibly indicating the page is about to terminate – requests will not be
+ * rate limited, to ensure that they are not lost.
+ *
+ * TODO: If there are requests in the queue waiting to be sent when the page transitions to "hidden," these will not
+ * be immediately sent. This means there still is an edge case in which a request may be lost on page termination. This
+ * can be fixed with changes to `createMappingHandler`.
+ *
+ * **NOTE:** Under the hood, requests that come in faster than the set `duration` are placed in an unbounded buffer.
+ * If many requests are made quickly and `duration` is long, this could result in high memory usage. Keep this in mind
+ * when using this handler.
+ *
+ * @param duration In milliseconds. Requests will be passed to the next handler in the chain no faster than this. That
+ * is, if `duration` is `1000`, the next handler will be called at most once per second.
+ * @param pageVisibility Determines whether to flush buffered requests when the page becomes hidden.
+ * `false` value indicates that page visibility handling is avoided, while
+ * a {@link PageVisibility} instance is used to subscribe to page visibility change events.
+ * @returns {@link ChainableHandler}, suitable for use in {@link HandlerChainBuilder.map}
+ */
+export declare const createRateLimitingHandler: <Req, Res, Meta extends RequestMetadata>(duration: number, pageVisibility: PageVisibility | false) => ChainableHandler<Req, Res, Req, Res, Meta>;
+//# sourceMappingURL=rateLimitingHandler.d.ts.map

package/dist/handlers/rateLimitingHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rateLimitingHandler.d.ts","sourceRoot":"","sources":["../../src/handlers/rateLimitingHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAK/E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,yBAAyB,qDACxB,MAAM,kBACA,cAAc,GAAG,KAAK,+CAwBzC,CAAC"}

package/dist/handlers/rateLimitingHandler.js

@@ -0,0 +1,21 @@
+import { __awaiter } from "tslib";
+import { createMappingHandler } from "./mappingHandler";
+const delay = (duration) => new Promise((resolve) => setTimeout(resolve, duration));
+export const createRateLimitingHandler = (duration, pageVisibility) => {
+    let mostRecentSendTime = undefined;
+    const mappingHandler = createMappingHandler((request) => __awaiter(void 0, void 0, void 0, function* () {
+        if (mostRecentSendTime !== undefined) {
+            const millisUntilNextSend = duration - (Date.now() - mostRecentSendTime);
+            if (millisUntilNextSend > 0)
+                yield delay(millisUntilNextSend);
+        }
+        mostRecentSendTime = Date.now();
+        return request;
+    }), pageVisibility, 1);
+    return (next) => (request, metadata) => {
+        if (pageVisibility && pageVisibility.isDuringVisibilityTransition("hidden"))
+            return next(request, metadata);
+        return mappingHandler(next)(request, metadata);
+    };
+};
+//# sourceMappingURL=rateLimitingHandler.js.map

package/dist/handlers/rateLimitingHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rateLimitingHandler.js","sourceRoot":"","sources":["../../src/handlers/rateLimitingHandler.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,KAAK,GAAG,CAAC,QAAgB,EAAE,EAAE,CAAC,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;AAuBlG,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACrC,QAAgB,EAChB,cAAsC,EACI,EAAE;IAC5C,IAAI,kBAAkB,GAAuB,SAAS,CAAC;IAEvD,MAAM,cAAc,GAAG,oBAAoB,CACvC,CAAO,OAAO,EAAE,EAAE;QACd,IAAI,kBAAkB,KAAK,SAAS,EAAE;YAClC,MAAM,mBAAmB,GAAG,QAAQ,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,kBAAkB,CAAC,CAAC;YACzE,IAAI,mBAAmB,GAAG,CAAC;gBAAE,MAAM,KAAK,CAAC,mBAAmB,CAAC,CAAC;SACjE;QACD,kBAAkB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAChC,OAAO,OAAO,CAAC;IACnB,CAAC,CAAA,EACD,cAAc,EACd,CAAC,CACJ,CAAC;IAEF,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,EAAE;QAInC,IAAI,cAAc,IAAI,cAAc,CAAC,4BAA4B,CAAC,QAAQ,CAAC;YAAE,OAAO,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;QAC5G,OAAO,cAAc,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IACnD,CAAC,CAAC;AACN,CAAC,CAAC","sourcesContent":["import type { PageVisibility } from \"../common/pageVisibility\";\nimport type { ChainableHandler, RequestMetadata } from \"./HandlerChainBuilder\";\nimport { createMappingHandler } from \"./mappingHandler\";\n\nconst delay = (duration: number) => new Promise<void>((resolve) => setTimeout(resolve, duration));\n\n/**\n * Limit the rate at which requests are passed to the next handler in the chain.\n *\n * During any page transitions to \"hidden\" – possibly indicating the page is about to terminate – requests will not be\n * rate limited, to ensure that they are not lost.\n *\n * TODO: If there are requests in the queue waiting to be sent when the page transitions to \"hidden,\" these will not\n * be immediately sent. This means there still is an edge case in which a request may be lost on page termination. This\n * can be fixed with changes to `createMappingHandler`.\n *\n * **NOTE:** Under the hood, requests that come in faster than the set `duration` are placed in an unbounded buffer.\n * If many requests are made quickly and `duration` is long, this could result in high memory usage. Keep this in mind\n * when using this handler.\n *\n * @param duration In milliseconds. Requests will be passed to the next handler in the chain no faster than this. That\n * is, if `duration` is `1000`, the next handler will be called at most once per second.\n * @param pageVisibility Determines whether to flush buffered requests when the page becomes hidden.\n * `false` value indicates that page visibility handling is avoided, while\n * a {@link PageVisibility} instance is used to subscribe to page visibility change events.\n * @returns {@link ChainableHandler}, suitable for use in {@link HandlerChainBuilder.map}\n */\nexport const createRateLimitingHandler = <Req, Res, Meta extends RequestMetadata>(\n    duration: number,\n    pageVisibility: PageVisibility | false\n): ChainableHandler<Req, Res, Req, Res, Meta> => {\n    let mostRecentSendTime: number | undefined = undefined;\n\n    const mappingHandler = createMappingHandler<Req, Req, Res, Meta>(\n        async (request) => {\n            if (mostRecentSendTime !== undefined) {\n                const millisUntilNextSend = duration - (Date.now() - mostRecentSendTime);\n                if (millisUntilNextSend > 0) await delay(millisUntilNextSend);\n            }\n            mostRecentSendTime = Date.now();\n            return request;\n        },\n        pageVisibility,\n        1\n    );\n\n    return (next) => (request, metadata) => {\n        // Requests may be made while the page is transitioning to hidden – for example, the page is being unloaded and\n        // we're reporting final metrics. In this case, we need to skip rate limiting and synchronously call `next`\n        // so that the request is not lost.\n        if (pageVisibility && pageVisibility.isDuringVisibilityTransition(\"hidden\")) return next(request, metadata);\n        return mappingHandler(next)(request, metadata);\n    };\n};\n"]}

package/dist/handlers/requestStateEmittingHandler.d.ts

@@ -0,0 +1,42 @@
+import { TypedCustomEvent } from "../events/TypedCustomEvent";
+import { TypedEventTarget } from "../events/TypedEventTarget";
+import { Timer } from "../metrics/operational/Timer";
+import type { ChainableHandler, RequestMetadata } from "./HandlerChainBuilder";
+interface Started {
+    requestId: number;
+    timer: Timer<"download_latency">;
+    dimensions: Dimensions;
+}
+interface Completed {
+    requestId: number;
+    dimensions: Dimensions;
+    status: number;
+    sizeByte: number;
+}
+interface Errored {
+    requestId: number;
+    dimensions: Dimensions;
+    error: Error;
+}
+export type Dimensions = Record<string, string | undefined>;
+export type RequestStateEvents = TypedCustomEvent<"started", Started> | TypedCustomEvent<"completed", Completed> | TypedCustomEvent<"errored", Errored>;
+export declare const dispatchRequestStarted: (requestStateEventTarget: RequestStateEventTarget, data: Omit<Started, "requestId" | "timer">) => Started;
+export declare const dispatchRequestCompleted: (requestStateEventTarget: RequestStateEventTarget, data: Completed) => Completed;
+export declare const dispatchRequestErrored: (requestStateEventTarget: RequestStateEventTarget, data: Errored) => Errored;
+export declare const createRequestStateEmittingHandler: <D extends Dimensions = Dimensions>(requestStateEventTarget: RequestStateEventTarget) => ChainableHandler<[RequestInfo, D], Response, RequestInfo, Response, RequestMetadata>;
+/**
+ * This event target may be used to listen for any network request state changes initiated by CameraKit.
+ *
+ * @internal
+ */
+export type RequestStateEventTarget = TypedEventTarget<RequestStateEvents>;
+/**
+ * @internal
+ */
+export declare const requestStateEventTargetFactory: {
+    (): RequestStateEventTarget;
+    token: "requestStateEventTarget";
+    dependencies: [];
+};
+export {};
+//# sourceMappingURL=requestStateEmittingHandler.d.ts.map

package/dist/handlers/requestStateEmittingHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestStateEmittingHandler.d.ts","sourceRoot":"","sources":["../../src/handlers/requestStateEmittingHandler.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAS/E,UAAU,OAAO;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC;IACjC,UAAU,EAAE,UAAU,CAAC;CAC1B;AAED,UAAU,SAAS;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,OAAO;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,UAAU,CAAC;IACvB,KAAK,EAAE,KAAK,CAAC;CAChB;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;AAE5D,MAAM,MAAM,kBAAkB,GACxB,gBAAgB,CAAC,SAAS,EAAE,OAAO,CAAC,GACpC,gBAAgB,CAAC,WAAW,EAAE,SAAS,CAAC,GACxC,gBAAgB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;AAE3C,eAAO,MAAM,sBAAsB,4BACN,uBAAuB,QAC1C,KAAK,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,KAC3C,OAIF,CAAC;AAEF,eAAO,MAAM,wBAAwB,4BACR,uBAAuB,QAC1C,SAAS,KAChB,SAGF,CAAC;AAEF,eAAO,MAAM,sBAAsB,4BAA6B,uBAAuB,QAAQ,OAAO,KAAG,OAGxG,CAAC;AAEF,eAAO,MAAM,iCAAiC,+DAEb,uBAAuB,yFAenD,CAAC;AAEN;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG,gBAAgB,CAAC,kBAAkB,CAAC,CAAC;AAE3E;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;CAG1C,CAAC"}

package/dist/handlers/requestStateEmittingHandler.js

@@ -0,0 +1,42 @@
+import { __awaiter } from "tslib";
+import { ensureError } from "../common/errorHelpers";
+import { Injectable } from "../dependency-injection/Injectable";
+import { TypedCustomEvent } from "../events/TypedCustomEvent";
+import { TypedEventTarget } from "../events/TypedEventTarget";
+import { Timer } from "../metrics/operational/Timer";
+let requestId = 0;
+const safeParseInt = (str) => {
+    if (str == null)
+        return 0;
+    const maybeInt = parseInt(str);
+    return isNaN(maybeInt) ? 0 : maybeInt;
+};
+export const dispatchRequestStarted = (requestStateEventTarget, data) => {
+    const started = Object.assign(Object.assign({}, data), { requestId: requestId++, timer: new Timer("download_latency") });
+    requestStateEventTarget.dispatchEvent(new TypedCustomEvent("started", started));
+    return started;
+};
+export const dispatchRequestCompleted = (requestStateEventTarget, data) => {
+    requestStateEventTarget.dispatchEvent(new TypedCustomEvent("completed", data));
+    return data;
+};
+export const dispatchRequestErrored = (requestStateEventTarget, data) => {
+    requestStateEventTarget.dispatchEvent(new TypedCustomEvent("errored", data));
+    return data;
+};
+export const createRequestStateEmittingHandler = (requestStateEventTarget) => (next) => ([request, dimensions], metadata) => __awaiter(void 0, void 0, void 0, function* () {
+    const { requestId } = dispatchRequestStarted(requestStateEventTarget, { dimensions });
+    try {
+        const response = yield next(request, metadata);
+        const status = response.status;
+        const sizeByte = safeParseInt(response.headers.get("content-length"));
+        dispatchRequestCompleted(requestStateEventTarget, { requestId, dimensions, status, sizeByte });
+        return response;
+    }
+    catch (error) {
+        dispatchRequestErrored(requestStateEventTarget, { requestId, dimensions, error: ensureError(error) });
+        throw error;
+    }
+});
+export const requestStateEventTargetFactory = Injectable("requestStateEventTarget", () => new TypedEventTarget());
+//# sourceMappingURL=requestStateEmittingHandler.js.map

package/dist/handlers/requestStateEmittingHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestStateEmittingHandler.js","sourceRoot":"","sources":["../../src/handlers/requestStateEmittingHandler.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAGrD,IAAI,SAAS,GAAG,CAAC,CAAC;AAClB,MAAM,YAAY,GAAG,CAAC,GAAkB,EAAE,EAAE;IACxC,IAAI,GAAG,IAAI,IAAI;QAAE,OAAO,CAAC,CAAC;IAC1B,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;IAC/B,OAAO,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;AAC1C,CAAC,CAAC;AA4BF,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAClC,uBAAgD,EAChD,IAA0C,EACnC,EAAE;IACT,MAAM,OAAO,mCAAiB,IAAI,KAAE,SAAS,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,IAAI,KAAK,CAAC,kBAAkB,CAAC,GAAE,CAAC;IACnG,uBAAuB,CAAC,aAAa,CAAC,IAAI,gBAAgB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC;IAChF,OAAO,OAAO,CAAC;AACnB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,CACpC,uBAAgD,EAChD,IAAe,EACN,EAAE;IACX,uBAAuB,CAAC,aAAa,CAAC,IAAI,gBAAgB,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC;IAC/E,OAAO,IAAI,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,uBAAgD,EAAE,IAAa,EAAW,EAAE;IAC/G,uBAAuB,CAAC,aAAa,CAAC,IAAI,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC;IAC7E,OAAO,IAAI,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,iCAAiC,GAC1C,CACI,uBAAgD,EACoC,EAAE,CAC1F,CAAC,IAAI,EAAE,EAAE,CACT,CAAO,CAAC,OAAO,EAAE,UAAU,CAAC,EAAE,QAAQ,EAAE,EAAE;IACtC,MAAM,EAAE,SAAS,EAAE,GAAG,sBAAsB,CAAC,uBAAuB,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;IACtF,IAAI;QACA,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;QAC/C,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;QAC/B,MAAM,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC,CAAC;QACtE,wBAAwB,CAAC,uBAAuB,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC/F,OAAO,QAAQ,CAAC;KACnB;IAAC,OAAO,KAAK,EAAE;QACZ,sBAAsB,CAAC,uBAAuB,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACtG,MAAM,KAAK,CAAC;KACf;AACL,CAAC,CAAA,CAAC;AAYN,MAAM,CAAC,MAAM,8BAA8B,GAAG,UAAU,CACpD,yBAAyB,EACzB,GAA4B,EAAE,CAAC,IAAI,gBAAgB,EAAE,CACxD,CAAC","sourcesContent":["import { ensureError } from \"../common/errorHelpers\";\nimport { Injectable } from \"../dependency-injection/Injectable\";\nimport { TypedCustomEvent } from \"../events/TypedCustomEvent\";\nimport { TypedEventTarget } from \"../events/TypedEventTarget\";\nimport { Timer } from \"../metrics/operational/Timer\";\nimport type { ChainableHandler, RequestMetadata } from \"./HandlerChainBuilder\";\n\nlet requestId = 0;\nconst safeParseInt = (str: string | null) => {\n    if (str == null) return 0;\n    const maybeInt = parseInt(str);\n    return isNaN(maybeInt) ? 0 : maybeInt;\n};\n\ninterface Started {\n    requestId: number;\n    timer: Timer<\"download_latency\">;\n    dimensions: Dimensions;\n}\n\ninterface Completed {\n    requestId: number;\n    dimensions: Dimensions;\n    status: number;\n    sizeByte: number;\n}\n\ninterface Errored {\n    requestId: number;\n    dimensions: Dimensions;\n    error: Error;\n}\n\nexport type Dimensions = Record<string, string | undefined>;\n\nexport type RequestStateEvents =\n    | TypedCustomEvent<\"started\", Started>\n    | TypedCustomEvent<\"completed\", Completed>\n    | TypedCustomEvent<\"errored\", Errored>;\n\nexport const dispatchRequestStarted = (\n    requestStateEventTarget: RequestStateEventTarget,\n    data: Omit<Started, \"requestId\" | \"timer\">\n): Started => {\n    const started: Started = { ...data, requestId: requestId++, timer: new Timer(\"download_latency\") };\n    requestStateEventTarget.dispatchEvent(new TypedCustomEvent(\"started\", started));\n    return started;\n};\n\nexport const dispatchRequestCompleted = (\n    requestStateEventTarget: RequestStateEventTarget,\n    data: Completed\n): Completed => {\n    requestStateEventTarget.dispatchEvent(new TypedCustomEvent(\"completed\", data));\n    return data;\n};\n\nexport const dispatchRequestErrored = (requestStateEventTarget: RequestStateEventTarget, data: Errored): Errored => {\n    requestStateEventTarget.dispatchEvent(new TypedCustomEvent(\"errored\", data));\n    return data;\n};\n\nexport const createRequestStateEmittingHandler =\n    <D extends Dimensions = Dimensions>(\n        requestStateEventTarget: RequestStateEventTarget\n    ): ChainableHandler<[RequestInfo, D], Response, RequestInfo, Response, RequestMetadata> =>\n    (next) =>\n    async ([request, dimensions], metadata) => {\n        const { requestId } = dispatchRequestStarted(requestStateEventTarget, { dimensions });\n        try {\n            const response = await next(request, metadata);\n            const status = response.status;\n            const sizeByte = safeParseInt(response.headers.get(\"content-length\"));\n            dispatchRequestCompleted(requestStateEventTarget, { requestId, dimensions, status, sizeByte });\n            return response;\n        } catch (error) {\n            dispatchRequestErrored(requestStateEventTarget, { requestId, dimensions, error: ensureError(error) });\n            throw error;\n        }\n    };\n\n/**\n * This event target may be used to listen for any network request state changes initiated by CameraKit.\n *\n * @internal\n */\nexport type RequestStateEventTarget = TypedEventTarget<RequestStateEvents>;\n\n/**\n * @internal\n */\nexport const requestStateEventTargetFactory = Injectable(\n    \"requestStateEventTarget\",\n    (): RequestStateEventTarget => new TypedEventTarget()\n);\n"]}