api-def 0.12.1 → 0.14.0-alpha.1

package/esm/backend/AxiosRequestBackend.js

@@ -1,38 +1,4 @@
-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());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
-};
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
-import { inferResponseType } from "../ApiUtils";
+import { inferResponseType } from "../ApiUtils.js";
 let axios;
 export const isAxiosError = (error) => {
     return "isAxiosError" in error;
@@ -66,56 +32,50 @@ export default class AxiosRequestBackend {
         this.id = "axios";
         axios = axiosLibrary;
     }
-    extractResponseFromError(error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (isAxiosError(error)) {
-                return error.response ? error.response : null;
-            }
-            return undefined;
-        });
+    async extractResponseFromError(error) {
+        if (isAxiosError(error)) {
+            return error.response ? error.response : null;
+        }
+        return undefined;
     }
-    convertResponse(context, response) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e;
-            const responseType = (_a = context.responseType) !== null && _a !== void 0 ? _a : inferResponseType(response.headers["content-type"]);
-            let data;
-            if (responseType === "stream") {
-                // For streaming responses, we create an async iterator from the response data
-                if (!response.data) {
-                    throw new Error("[api-def] Response data is null for streaming response");
-                }
-                data = {
-                    [Symbol.asyncIterator]() {
-                        return __asyncGenerator(this, arguments, function* _a() {
-                            const stream = response.data;
-                            if (stream[Symbol.asyncIterator]) {
-                                yield __await(yield* __asyncDelegator(__asyncValues(stream)));
-                            }
-                            else if (stream.on) {
-                                // Handle Node.js streams
-                                yield __await(yield* __asyncDelegator(__asyncValues(stream)));
-                            }
-                            else {
-                                throw new Error("[api-def] Response data is not a valid stream");
-                            }
-                        });
-                    },
-                };
+    async convertResponse(context, response) {
+        const contentType = response.headers["content-type"];
+        const responseType = context.responseType ?? inferResponseType(contentType == null ? contentType : String(contentType));
+        let data;
+        if (responseType === "stream") {
+            // For streaming responses, we create an async iterator from the response data
+            if (!response.data) {
+                throw new Error("[api-def] Response data is null for streaming response");
             }
-            else {
-                data = response.data;
-            }
-            return {
-                method: context.method,
-                url: (_c = (_b = response.request.res) === null || _b === void 0 ? void 0 : _b.responseUrl) !== null && _c !== void 0 ? _c : (_e = (_d = response.request) === null || _d === void 0 ? void 0 : _d._redirectable) === null || _e === void 0 ? void 0 : _e._currentUrl,
-                data: data,
-                headers: response.headers,
-                status: response.status,
-                state: context.requestConfig.state,
-                __lowercaseHeaders: response._lowerCaseResponseHeaders,
-                stats: context.stats,
+            data = {
+                async *[Symbol.asyncIterator]() {
+                    const stream = response.data;
+                    if (stream[Symbol.asyncIterator]) {
+                        yield* stream;
+                    }
+                    else if (stream.on) {
+                        // Handle Node.js streams
+                        yield* stream;
+                    }
+                    else {
+                        throw new Error("[api-def] Response data is not a valid stream");
+                    }
+                },
             };
-        });
+        }
+        else {
+            data = response.data;
+        }
+        return {
+            method: context.method,
+            url: response.request.res?.responseUrl ?? response.request?._redirectable?._currentUrl,
+            data: data,
+            headers: response.headers,
+            status: response.status,
+            state: context.requestConfig.state,
+            __lowercaseHeaders: response._lowerCaseResponseHeaders,
+            stats: context.stats,
+        };
     }
     makeRequest(context) {
         const { requestConfig } = context;
@@ -125,7 +85,10 @@ export default class AxiosRequestBackend {
             method: context.method,
             url: url.href,
             data: context.getParsedBody(),
-            headers: Object.assign(Object.assign({}, getCacheHeaders(requestConfig.browserCache)), requestConfig.headers),
+            headers: {
+                ...getCacheHeaders(requestConfig.browserCache),
+                ...requestConfig.headers,
+            },
             responseType: context.responseType,
             withCredentials: requestConfig.credentials === "include" || requestConfig.credentials === "same-origin",
             cancelToken: new axios.CancelToken((cancellerFunc) => {
@@ -134,7 +97,7 @@ export default class AxiosRequestBackend {
         });
         return {
             promise: promise,
-            canceler: () => canceler === null || canceler === void 0 ? void 0 : canceler(),
+            canceler: () => canceler?.(),
         };
     }
     getErrorInfo(error, response) {

package/esm/backend/FetchRequestBackend.d.ts

@@ -1,8 +1,8 @@
-import type { ApiResponse } from "../ApiTypes";
-import type RequestContext from "../RequestContext";
-import { type Fetch } from "../Utils";
-import type { ConvertedApiResponse, RequestBackendErrorInfo, RequestOperation } from "./RequestBackend";
-import type RequestBackend from "./RequestBackend";
+import type { ApiResponse } from "../ApiTypes.js";
+import type RequestContext from "../RequestContext.js";
+import { type Fetch } from "../Utils.js";
+import type RequestBackend from "./RequestBackend.js";
+import type { ConvertedApiResponse, RequestBackendErrorInfo, RequestOperation } from "./RequestBackend.js";
 export default class FetchRequestBackend implements RequestBackend<Response> {
     fetch: (((input: RequestInfo | URL, init?: RequestInit) => Promise<Response>) & typeof fetch) | undefined;
     readonly id = "fetch";

package/esm/backend/FetchRequestBackend.js

@@ -1,16 +1,7 @@
-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());
-    });
-};
-import { inferResponseType } from "../ApiUtils";
-import { RequestErrorCode, convertToRequestError } from "../RequestError";
-import * as Utils from "../Utils";
-import { getGlobal, getGlobalFetch } from "../Utils";
+import { inferResponseType } from "../ApiUtils.js";
+import { convertToRequestError, RequestErrorCode } from "../RequestError.js";
+import * as Utils from "../Utils.js";
+import { getGlobal, getGlobalFetch } from "../Utils.js";
 class FetchError extends Error {
 }
 export default class FetchRequestBackend {
@@ -25,59 +16,54 @@ export default class FetchRequestBackend {
             }
         }
     }
-    extractResponseFromError(error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if ("response" in error) {
-                const fetchError = error;
-                return fetchError.response ? fetchError.response : null;
-            }
-            return undefined;
-        });
+    async extractResponseFromError(error) {
+        if ("response" in error) {
+            const fetchError = error;
+            return fetchError.response ? fetchError.response : null;
+        }
+        return undefined;
     }
-    convertResponse(context, response) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { status, headers } = response;
-            const convertedResponse = {
-                method: context.method,
-                url: response.url,
-                data: undefined,
-                status: status,
-                headers: headers,
-                state: context.requestConfig.state,
-                stats: context.stats,
-            };
-            const responseType = (_a = context.responseType) !== null && _a !== void 0 ? _a : inferResponseType(response.headers.get("Content-Type"));
-            let text;
-            let data;
-            try {
-                if (responseType === "arraybuffer") {
-                    data = yield response.arrayBuffer();
-                }
-                else if (responseType === "json") {
-                    text = yield response.text();
-                    data = JSON.parse(text);
-                }
-                else if (responseType === "stream") {
-                    data = response.body;
-                }
-                else {
-                    data = yield response.text();
-                }
+    async convertResponse(context, response) {
+        const { status, headers } = response;
+        const convertedResponse = {
+            method: context.method,
+            url: response.url,
+            data: undefined,
+            status: status,
+            headers: headers,
+            state: context.requestConfig.state,
+            stats: context.stats,
+        };
+        const responseType = context.responseType ?? inferResponseType(response.headers.get("Content-Type"));
+        let text;
+        let data;
+        try {
+            if (responseType === "arraybuffer") {
+                data = await response.arrayBuffer();
             }
-            catch (error) {
-                throw convertToRequestError({
-                    error: Object.assign(new Error(`[api-def] Failed to parse response as '${responseType}'${text ? `, got: ${text}` : ""}`), {
-                        cause: error,
-                    }),
-                    code: RequestErrorCode.REQUEST_MISMATCH_RESPONSE_TYPE,
-                    context: context,
-                    response: convertedResponse,
-                });
+            else if (responseType === "json") {
+                text = await response.text();
+                data = JSON.parse(text);
             }
-            convertedResponse.data = data;
-            return convertedResponse;
-        });
+            else if (responseType === "stream") {
+                data = response.body;
+            }
+            else {
+                data = await response.text();
+            }
+        }
+        catch (error) {
+            throw convertToRequestError({
+                error: Object.assign(new Error(`[api-def] Failed to parse response as '${responseType}'${text ? `, got: ${text}` : ""}`), {
+                    cause: error,
+                }),
+                code: RequestErrorCode.REQUEST_MISMATCH_RESPONSE_TYPE,
+                context: context,
+                response: convertedResponse,
+            });
+        }
+        convertedResponse.data = data;
+        return convertedResponse;
     }
     makeRequest(context) {
         if (!this.fetch) {
@@ -90,7 +76,7 @@ export default class FetchRequestBackend {
         let softAbort = false;
         let responded = false;
         const body = context.getParsedBody();
-        const bodyJsonify = body !== null && typeof body === "object" && !Utils.isFormData(body);
+        const bodyJsonify = body !== null && typeof body === "object" && !Utils.isFormData(body) && !(body instanceof URLSearchParams);
         const headers = Utils.assign({
             // logic from axios
             "Content-Type": bodyJsonify ? "application/json;charset=utf-8" : undefined,

package/esm/backend/MockRequestBackend.d.ts

@@ -1,7 +1,7 @@
-import type { ApiResponse } from "../ApiTypes";
-import type RequestContext from "../RequestContext";
-import type { RequestBackendErrorInfo, RequestOperation } from "./RequestBackend";
-import type RequestBackend from "./RequestBackend";
+import type { ApiResponse } from "../ApiTypes.js";
+import type RequestContext from "../RequestContext.js";
+import type RequestBackend from "./RequestBackend.js";
+import type { RequestBackendErrorInfo, RequestOperation } from "./RequestBackend.js";
 export default class MockRequestBackend implements RequestBackend<ApiResponse> {
     readonly id = "mock";
     convertResponse<T>(context: RequestContext, response: ApiResponse, error?: boolean): Promise<ApiResponse<T>>;

package/esm/backend/MockRequestBackend.js

@@ -1,151 +1,120 @@
-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());
-    });
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
-import { inferResponseType } from "../ApiUtils";
-import { RequestErrorCode, convertToRequestError } from "../RequestError";
-import * as Utils from "../Utils";
-import { delayThenReturn, randInt } from "../Utils";
+import { inferResponseType } from "../ApiUtils.js";
+import { convertToRequestError, RequestErrorCode } from "../RequestError.js";
+import * as Utils from "../Utils.js";
+import { delayThenReturn, randInt } from "../Utils.js";
 export default class MockRequestBackend {
     constructor() {
         this.id = "mock";
     }
-    convertResponse(context, response, error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return response;
-        });
+    async convertResponse(context, response, error) {
+        return response;
     }
-    extractResponseFromError(error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if ("response" in error) {
-                const fetchError = error;
-                return fetchError.response ? fetchError.response : null;
-            }
-            return undefined;
-        });
+    async extractResponseFromError(error) {
+        if ("response" in error) {
+            const fetchError = error;
+            return fetchError.response ? fetchError.response : null;
+        }
+        return undefined;
     }
-    runRequest(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f;
-            const mockingFunc = (_a = context.mocking) === null || _a === void 0 ? void 0 : _a.handler;
-            if (!mockingFunc) {
-                throw convertToRequestError({
-                    error: new Error("[api-def] Attempted to run mocked request without mocking function"),
-                    code: RequestErrorCode.REQUEST_INVALID_CONFIG,
-                    context,
-                });
-            }
-            const req = {
-                body: context.getParsedBody(),
-                params: (_b = context.requestConfig.params) !== null && _b !== void 0 ? _b : {},
-                query: context.requestConfig.queryObject,
-                headers: (_c = context.requestConfig.headers) !== null && _c !== void 0 ? _c : {},
-                url: context.requestUrl.toString(),
-                state: context.requestConfig.state,
-            };
-            const res = {
-                statusCode: -1,
-                headers: {},
-                response: undefined,
-                status(statusCode) {
-                    res.statusCode = statusCode;
-                    return res;
-                },
-                send(response) {
-                    res.response = response;
-                    if (response && typeof response === "object") {
-                        res.headers["Content-Type"] = "application/json";
-                    }
-                    return res;
-                },
-            };
-            if ((_d = context.mocking) === null || _d === void 0 ? void 0 : _d.delay) {
-                const delay = context.mocking.delay;
-                let delayMs;
-                if (typeof delay === "number") {
-                    delayMs = delay;
-                }
-                else {
-                    const [min, max] = delay;
-                    if (min > max) {
-                        throw convertToRequestError({
-                            error: new Error("[api-def] Min delay cannot be greater than max delay"),
-                            code: RequestErrorCode.REQUEST_INVALID_CONFIG,
-                            context,
-                        });
-                    }
-                    delayMs = randInt(min, max);
+    async runRequest(context) {
+        const mockingFunc = context.mocking?.handler;
+        if (!mockingFunc) {
+            throw convertToRequestError({
+                error: new Error("[api-def] Attempted to run mocked request without mocking function"),
+                code: RequestErrorCode.REQUEST_INVALID_CONFIG,
+                context,
+            });
+        }
+        const req = {
+            body: context.getParsedBody(),
+            params: context.requestConfig.params ?? {},
+            query: context.requestConfig.queryObject,
+            headers: context.requestConfig.headers ?? {},
+            url: context.requestUrl.toString(),
+            state: context.requestConfig.state,
+        };
+        const res = {
+            statusCode: -1,
+            headers: {},
+            response: undefined,
+            status(statusCode) {
+                res.statusCode = statusCode;
+                return res;
+            },
+            send(response) {
+                res.response = response;
+                if (response && typeof response === "object") {
+                    res.headers["Content-Type"] = "application/json";
                 }
-                yield delayThenReturn(yield mockingFunc(req, res), delayMs);
+                return res;
+            },
+        };
+        if (context.mocking?.delay) {
+            const delay = context.mocking.delay;
+            let delayMs;
+            if (typeof delay === "number") {
+                delayMs = delay;
             }
             else {
-                yield mockingFunc(req, res);
-            }
-            if (res.response === undefined) {
-                throw convertToRequestError({
-                    error: new Error("[api-def] Mocked API did not respond"),
-                    code: RequestErrorCode.REQUEST_INVALID_CONFIG,
-                    context,
-                });
+                const [min, max] = delay;
+                if (min > max) {
+                    throw convertToRequestError({
+                        error: new Error("[api-def] Min delay cannot be greater than max delay"),
+                        code: RequestErrorCode.REQUEST_INVALID_CONFIG,
+                        context,
+                    });
+                }
+                delayMs = randInt(min, max);
             }
-            const parsedHeaders = Object.keys(res.headers).reduce((parsedHeaders, key) => {
-                parsedHeaders.set(key, res.headers[key].toString());
-                return parsedHeaders;
-            }, new Headers());
-            const responseType = (_e = context.responseType) !== null && _e !== void 0 ? _e : inferResponseType((_f = res.headers["content-type"]) === null || _f === void 0 ? void 0 : _f.toString());
-            let data;
-            if (responseType === "stream") {
-                // For streaming responses, we create a mock async iterator
-                data = {
-                    [Symbol.asyncIterator]() {
-                        return __asyncGenerator(this, arguments, function* _a() {
-                            if (res.response) {
-                                // If the response is an array, yield each item
-                                if (Array.isArray(res.response)) {
-                                    for (const item of res.response) {
-                                        yield yield __await(new TextEncoder().encode(`${JSON.stringify(item)}\n`));
-                                    }
-                                }
-                                else {
-                                    // Otherwise yield the entire response
-                                    yield yield __await(new TextEncoder().encode(`${JSON.stringify(res.response)}\n`));
-                                }
+            await delayThenReturn(await mockingFunc(req, res), delayMs);
+        }
+        else {
+            await mockingFunc(req, res);
+        }
+        if (res.response === undefined) {
+            throw convertToRequestError({
+                error: new Error("[api-def] Mocked API did not respond"),
+                code: RequestErrorCode.REQUEST_INVALID_CONFIG,
+                context,
+            });
+        }
+        const parsedHeaders = Object.keys(res.headers).reduce((parsedHeaders, key) => {
+            parsedHeaders.set(key, res.headers[key].toString());
+            return parsedHeaders;
+        }, new Headers());
+        const responseType = context.responseType ?? inferResponseType(res.headers["content-type"]?.toString());
+        let data;
+        if (responseType === "stream") {
+            // For streaming responses, we create a mock async iterator
+            data = {
+                async *[Symbol.asyncIterator]() {
+                    if (res.response) {
+                        // If the response is an array, yield each item
+                        if (Array.isArray(res.response)) {
+                            for (const item of res.response) {
+                                yield new TextEncoder().encode(`${JSON.stringify(item)}\n`);
                             }
-                        });
-                    },
-                };
-            }
-            else {
-                data = res.response;
-            }
-            return {
-                url: context.requestUrl.href,
-                method: context.method,
-                headers: parsedHeaders,
-                data: data,
-                status: res.statusCode,
-                state: context.requestConfig.state,
-                stats: context.stats,
+                        }
+                        else {
+                            // Otherwise yield the entire response
+                            yield new TextEncoder().encode(`${JSON.stringify(res.response)}\n`);
+                        }
+                    }
+                },
             };
-        });
+        }
+        else {
+            data = res.response;
+        }
+        return {
+            url: context.requestUrl.href,
+            method: context.method,
+            headers: parsedHeaders,
+            data: data,
+            status: res.statusCode,
+            state: context.requestConfig.state,
+            stats: context.stats,
+        };
     }
     makeRequest(context) {
         return {

package/esm/backend/RequestBackend.d.ts

@@ -1,5 +1,5 @@
-import type { ApiResponse } from "../ApiTypes";
-import type RequestContext from "../RequestContext";
+import type { ApiResponse } from "../ApiTypes.js";
+import type RequestContext from "../RequestContext.js";
 export interface RequestOperation<R> {
     promise: Promise<R>;
     canceler: () => void;

package/esm/cache/ClientCaching.d.ts

@@ -1,4 +1,4 @@
-import type { ClientCacheBackend } from "./ClientCacheBackend";
+import type { ClientCacheBackend } from "./ClientCacheBackend.js";
 export declare const setClientCacheBackend: (backend: ClientCacheBackend) => void;
 export declare const DEFAULT_CLIENT_CACHE_EXPIRY: number;
 export declare const clearClientCache: () => Promise<void>;

package/esm/cache/ClientCaching.js

@@ -1,13 +1,4 @@
-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());
-    });
-};
-import LocalStorageClientCacheBackend from "./LocalStorageClientCacheBackend";
+import LocalStorageClientCacheBackend from "./LocalStorageClientCacheBackend.js";
 let clientCacheBackend = new LocalStorageClientCacheBackend();
 export const setClientCacheBackend = (backend) => {
     clientCacheBackend = backend;
@@ -16,24 +7,24 @@ export const DEFAULT_CLIENT_CACHE_EXPIRY = /* 15 mins */ 60 * 1000 * 15;
 export const clearClientCache = () => {
     return clientCacheBackend.clear();
 };
-export const setClientCachedItem = (key, value, expiry) => __awaiter(void 0, void 0, void 0, function* () {
+export const setClientCachedItem = async (key, value, expiry) => {
     const entry = {
         data: value,
         expiry: expiry === undefined || Number.isNaN(expiry) ? null : expiry,
     };
-    yield clientCacheBackend.setItem(key, entry);
+    await clientCacheBackend.setItem(key, entry);
     return value;
-});
-export const getClientCachedItem = (key) => __awaiter(void 0, void 0, void 0, function* () {
-    const entry = yield clientCacheBackend.getItem(key);
+};
+export const getClientCachedItem = async (key) => {
+    const entry = await clientCacheBackend.getItem(key);
     if (!entry) {
         return undefined;
     }
     if (typeof entry.expiry === "number") {
         if (Date.now() >= entry.expiry) {
-            yield clientCacheBackend.removeItem(key);
+            await clientCacheBackend.removeItem(key);
             return undefined;
         }
     }
     return entry.data;
-});
+};