@jacraig/request 1.0.0

package/lib/Request.umd.js

@@ -0,0 +1,475 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@jacraig/woodchuck')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@jacraig/woodchuck'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.request = {}, global.woodchuck));
+})(this, (function (exports, woodchuck) { 'use strict';
+
+    class DatabaseConnection {
+        constructor(dbName, tables, version) {
+            this.dbName = dbName;
+            this.tables = tables;
+            this.version = version;
+            const request = indexedDB.open(dbName, version);
+            request.onupgradeneeded = (ev) => {
+                this.database = ev.target.result;
+                if (!this.database) {
+                    return;
+                }
+                for (const table of tables) {
+                    if (this.database.objectStoreNames.contains(table)) {
+                        this.database.deleteObjectStore(table);
+                    }
+                    this.database.createObjectStore(table);
+                }
+            };
+            request.onsuccess = (ev) => {
+                this.database = ev.target.result;
+            };
+            request.onerror = (ev) => {
+                woodchuck.Logger.error('Failed to open the database:', ev.target.error);
+            };
+        }
+        openDatabase() {
+            return new Promise((resolve, reject) => {
+                const request = indexedDB.open(this.dbName, this.version);
+                request.onsuccess = (ev) => {
+                    this.database = ev.target.result;
+                    resolve(this);
+                };
+                request.onerror = (ev) => {
+                    woodchuck.Logger.error('Failed to open the database:', ev.target.error);
+                    reject(new Error('Failed to open the database:' + ev.target.error));
+                };
+            });
+        }
+        add(table, obj, key) {
+            return new Promise((resolve, reject) => {
+                if (!this.database) {
+                    woodchuck.Logger.error('Database connection is not open');
+                    reject(new Error('Database connection is not open'));
+                    return;
+                }
+                const transaction = this.database.transaction(table, 'readwrite');
+                const objectStore = transaction.objectStore(table);
+                const request = objectStore.put(obj, key);
+                request.onsuccess = () => {
+                    resolve();
+                };
+                request.onerror = (ev) => {
+                    woodchuck.Logger.error('Failed to add an object to the database: ', ev.target.error);
+                    reject(new Error('Failed to add an object to the database: ' + ev.target.error));
+                };
+            });
+        }
+        remove(table, key) {
+            return new Promise((resolve, reject) => {
+                if (!this.database) {
+                    woodchuck.Logger.error('Database connection is not open');
+                    reject(new Error('Database connection is not open'));
+                    return;
+                }
+                const transaction = this.database.transaction(table, 'readwrite');
+                const objectStore = transaction.objectStore(table);
+                const request = objectStore.delete(key);
+                request.onsuccess = () => {
+                    resolve();
+                };
+                request.onerror = (ev) => {
+                    woodchuck.Logger.error('Failed to remove an object from the database: ', ev.target.error);
+                    reject(new Error('Failed to remove an object from the database: ' + ev.target.error));
+                };
+            });
+        }
+        getByKey(table, key) {
+            return new Promise((resolve, reject) => {
+                if (!this.database) {
+                    woodchuck.Logger.error('Database connection is not open');
+                    reject(new Error('Database connection is not open'));
+                    return;
+                }
+                const transaction = this.database.transaction(table, 'readwrite');
+                const objectStore = transaction.objectStore(table);
+                const request = objectStore.get(key);
+                request.onsuccess = (ev) => {
+                    resolve(ev.target.result);
+                };
+                request.onerror = (ev) => {
+                    woodchuck.Logger.error('Failed to retrieve an object from the database: ', ev.target.error);
+                    reject(new Error('Failed to retrieve an object from the database: ' + ev.target.error));
+                };
+            });
+        }
+        getKeys(table) {
+            return new Promise((resolve, reject) => {
+                if (!this.database) {
+                    woodchuck.Logger.error('Database connection is not open');
+                    reject(new Error('Database connection is not open'));
+                    return;
+                }
+                const transaction = this.database.transaction(table, 'readwrite');
+                const objectStore = transaction.objectStore(table);
+                const request = objectStore.getAllKeys();
+                request.onsuccess = (ev) => {
+                    resolve(ev.target.result);
+                };
+                request.onerror = (ev) => {
+                    woodchuck.Logger.error('Failed to retrieve an object from the database: ', ev.target.error);
+                    reject(new Error('Failed to retrieve keys from the database: ' + ev.target.error));
+                };
+            });
+        }
+        get(table, query) {
+            return new Promise((resolve, reject) => {
+                if (!this.database) {
+                    woodchuck.Logger.error('Database connection is not open');
+                    reject(new Error('Database connection is not open'));
+                    return;
+                }
+                const transaction = this.database.transaction(table, 'readwrite');
+                const objectStore = transaction.objectStore(table);
+                const request = objectStore.get(query);
+                request.onsuccess = (ev) => {
+                    resolve(ev.target.result);
+                };
+                request.onerror = (ev) => {
+                    woodchuck.Logger.error('Failed to retrieve an object from the database: ', ev.target.error);
+                    reject(new Error('Failed to retrieve an object from the database: ' + ev.target.error));
+                };
+            });
+        }
+        getAll(table, query) {
+            return new Promise((resolve, reject) => {
+                if (!this.database) {
+                    woodchuck.Logger.error('Database connection is not open');
+                    reject(new Error('Database connection is not open'));
+                    return;
+                }
+                const transaction = this.database.transaction(table, 'readwrite');
+                const objectStore = transaction.objectStore(table);
+                const request = objectStore.getAll(query);
+                request.onsuccess = (ev) => {
+                    resolve(ev.target.result);
+                };
+                request.onerror = (ev) => {
+                    woodchuck.Logger.error('Failed to retrieve an object from the database: ', ev.target.error);
+                    reject(new Error('Failed to retrieve objects from the database: ' + ev.target.error));
+                };
+            });
+        }
+    }
+
+    class IndexedDbStorageProvider {
+        constructor() {
+            this.database = new DatabaseConnection("cacheStore", ["cache", "cacheEntryOptions"], 1);
+        }
+        async clear() {
+            await this.database.openDatabase();
+            let cacheEntryOptions = await this.database.getAll("cacheEntryOptions");
+            let cacheEntries = await this.database.getAll("cache");
+            for (let i = 0; i < cacheEntryOptions.length; i++) {
+                let cacheEntry = cacheEntries[i];
+                await this.remove(cacheEntry.key);
+            }
+            return this;
+        }
+        async getOptions(key) {
+            await this.database.openDatabase();
+            return this.database.getByKey("cacheEntryOptions", key);
+        }
+        async add(obj, key, options) {
+            await this.database.openDatabase();
+            await this.database.add("cache", obj, key);
+            await this.database.add("cacheEntryOptions", options, key);
+            return this;
+        }
+        async remove(key) {
+            await this.database.openDatabase();
+            await this.database.remove("cache", key);
+            await this.database.remove("cacheEntryOptions", key);
+            return this;
+        }
+        async get(key) {
+            await this.database.openDatabase();
+            return this.database.getByKey("cache", key);
+        }
+        async compact() {
+            await this.database.openDatabase();
+            let cacheEntryOptions = await this.database.getAll("cacheEntryOptions");
+            let cacheEntries = await this.database.getAll("cache");
+            let now = new Date().getTime();
+            for (let i = 0; i < cacheEntryOptions.length; i++) {
+                let cacheEntryOption = cacheEntryOptions[i];
+                let cacheEntry = cacheEntries[i];
+                if (cacheEntryOption.expirationTime == 0) {
+                    continue;
+                }
+                if (cacheEntryOption.expirationTime < now) {
+                    await this.remove(cacheEntry.key);
+                }
+            }
+            return this;
+        }
+    }
+    class Cache {
+        constructor() { }
+        static configure(storageProvider = new IndexedDbStorageProvider()) {
+            this.storageProvider ??= globalThis.StorageProvider || storageProvider || new IndexedDbStorageProvider();
+            globalThis.StorageProvider = this.storageProvider;
+        }
+        static async set(key, value, entryOptions = { expirationTime: 0, slidingExpirationTime: 0, sliding: false }) {
+            woodchuck.Logger.debug("Setting object in cache: ", { "key": key, "value": value, "entryOptions": entryOptions });
+            this.configure();
+            await this.storageProvider.add(value, key, entryOptions);
+        }
+        static async get(key) {
+            woodchuck.Logger.debug("Getting object from cache: " + key);
+            this.configure();
+            await this.storageProvider.compact();
+            let returnValue = await this.storageProvider.get(key);
+            if (returnValue == null) {
+                return returnValue;
+            }
+            let entryOptions = await this.storageProvider.getOptions(key);
+            if (entryOptions.sliding) {
+                await this.set(key, returnValue, {
+                    expirationTime: new Date().getTime() + entryOptions.slidingExpirationTime,
+                    slidingExpirationTime: entryOptions.slidingExpirationTime,
+                    sliding: true
+                });
+            }
+            return returnValue;
+        }
+        static async remove(key) {
+            woodchuck.Logger.debug("Removing object from cache: " + key);
+            this.configure();
+            await this.storageProvider.remove(key);
+        }
+        static async clear() {
+            woodchuck.Logger.debug("Clearing cache");
+            this.configure();
+            await this.storageProvider.clear();
+        }
+    }
+
+    class CancellationToken {
+        constructor() {
+            this.canceled = false;
+        }
+    }
+    class Request {
+        constructor(options) {
+            this.options = {
+                method: "GET",
+                url: "",
+                headers: {},
+                credentials: "same-origin",
+                serializer: JSON.stringify,
+                parser: (response) => response.json(),
+                success: (response) => { woodchuck.Logger.debug("Request response from " + this.options.url + ":", response); },
+                error: (reason) => { woodchuck.Logger.error("Request error from " + this.options.url + ":", reason); },
+                retry: (attempt) => { woodchuck.Logger.debug("Request retry on " + this.options.url + ":", { "attempt": attempt }); },
+                storageMode: exports.StorageMode.NetworkFirst,
+                cacheKey: "",
+                timeout: 60000,
+                retryAttempts: 3,
+                retryDelay: 1000
+            };
+            this.abortController = null;
+            this.options = { ...this.options, ...options };
+        }
+        static get(url, data) {
+            return new Request({ method: "GET", url, data, cacheKey: url + JSON.stringify(data) })
+                .withHeaders({
+                "Accept": "application/json"
+            });
+        }
+        static post(url, data) {
+            return new Request({ method: "POST", url, data, cacheKey: url + JSON.stringify(data), storageMode: exports.StorageMode.NetworkOnly })
+                .withHeaders({
+                "Content-Type": "application/json",
+                "Accept": "application/json"
+            });
+        }
+        static put(url, data) {
+            return new Request({ method: "PUT", url, data, cacheKey: url + JSON.stringify(data), storageMode: exports.StorageMode.NetworkOnly })
+                .withHeaders({
+                "Content-Type": "application/json",
+                "Accept": "application/json"
+            });
+        }
+        static delete(url, data) {
+            return new Request({ method: "DELETE", url, data, cacheKey: url + JSON.stringify(data), storageMode: exports.StorageMode.NetworkOnly })
+                .withHeaders({
+                "Accept": "application/json"
+            });
+        }
+        static ofType(method, url, data) {
+            return new Request({ method, url, data, cacheKey: url + JSON.stringify(data) })
+                .withHeaders({
+                "Accept": "application/json"
+            });
+        }
+        withAuthenticationProvider(authenticationProvider) {
+            this.options.authenticationProvider = authenticationProvider;
+            return this;
+        }
+        withHeaders(headers) {
+            this.options.headers = { ...this.options.headers, ...headers };
+            return this;
+        }
+        withCancellationToken(cancellationToken) {
+            this.options.cancellationToken = cancellationToken;
+            return this;
+        }
+        withCredentials(credentials) {
+            this.options.credentials = credentials;
+            return this;
+        }
+        withSerializer(serializer) {
+            this.options.serializer = serializer;
+            return this;
+        }
+        withParser(parser) {
+            this.options.parser = parser;
+            return this;
+        }
+        onSuccess(callback) {
+            this.options.success = callback ?? ((response) => { woodchuck.Logger.debug("Request response:", response); });
+            return this;
+        }
+        onError(callback) {
+            this.options.error = callback ?? ((reason) => { woodchuck.Logger.error("Request error:", reason); });
+            return this;
+        }
+        onRetry(callback) {
+            this.options.retry = callback ?? ((attempt) => { woodchuck.Logger.debug("Request retry:", { "attempt": attempt }); });
+            return this;
+        }
+        withStorageMode(storageMode) {
+            this.options.storageMode = storageMode;
+            return this;
+        }
+        withCacheKey(cacheKey) {
+            this.options.cacheKey = cacheKey;
+            return this;
+        }
+        withTimeout(timeout) {
+            this.options.timeout = timeout ?? 60000;
+            return this;
+        }
+        withRetryAttempts(retryAttempts) {
+            this.options.retryAttempts = retryAttempts;
+            return this;
+        }
+        withRetryDelay(retryDelay) {
+            this.options.retryDelay = retryDelay;
+            return this;
+        }
+        abort() {
+            if (this.abortController == null || this.options.error == null) {
+                return this;
+            }
+            this.abortController.abort();
+            this.options.error(new Error("The request was aborted."));
+            return this;
+        }
+        async send() {
+            const { authenticationProvider, method, url, data, headers, credentials, serializer, parser, success, error, storageMode, cacheKey, timeout, retryAttempts, retryDelay, retry, cancellationToken } = this.options;
+            const abortController = new AbortController();
+            this.abortController = abortController;
+            let attempts = 0;
+            let lastError = null;
+            let successMethod = success || ((response) => { woodchuck.Logger.debug("Request response from " + url + ":", response); });
+            let errorMethod = error || ((reason) => { woodchuck.Logger.error("Request error from " + url + ":", reason); });
+            let serializerMethod = serializer || JSON.stringify;
+            let parserMethod = parser || ((response) => response.json());
+            let retryMethod = retry || ((attempt) => { woodchuck.Logger.debug("Request retry on " + url + ":", { "attempt": attempt }); });
+            const sendRequest = async () => {
+                if (storageMode === exports.StorageMode.StorageFirst || storageMode === exports.StorageMode.StorageAndUpdate) {
+                    const cachedValue = await Cache.get(cacheKey || "");
+                    if (cachedValue !== undefined) {
+                        successMethod(cachedValue);
+                        if (storageMode === exports.StorageMode.StorageFirst) {
+                            return cachedValue;
+                        }
+                    }
+                }
+                if (!navigator.onLine) {
+                    if (storageMode === exports.StorageMode.NetworkFirst) {
+                        const cachedValue = await Cache.get(cacheKey || "");
+                        if (cachedValue !== undefined) {
+                            successMethod(cachedValue);
+                            return cachedValue;
+                        }
+                    }
+                    const errorMessage = new Error("System is offline");
+                    errorMethod(errorMessage);
+                    return Promise.reject(errorMessage);
+                }
+                try {
+                    const serializedData = serializerMethod(data);
+                    await authenticationProvider?.authenticate(this);
+                    const response = await Promise.race([
+                        fetch(url, {
+                            method,
+                            credentials,
+                            headers,
+                            body: serializedData,
+                            signal: abortController.signal,
+                        }),
+                        this.handleTimeout(timeout)
+                    ]);
+                    if (cancellationToken?.canceled) {
+                        return Promise.reject(new Error("The request was canceled."));
+                    }
+                    if (response.status >= 200 && response.status < 300) {
+                        const parsedResponse = await parserMethod(response);
+                        successMethod(parsedResponse);
+                        if (storageMode !== exports.StorageMode.NetworkOnly) {
+                            await Cache.set(cacheKey || "", parsedResponse);
+                        }
+                        return parsedResponse;
+                    }
+                    lastError = new Error(response.statusText);
+                    if (response.status === 401) {
+                        await authenticationProvider?.authenticationFailed(this, response);
+                    }
+                }
+                catch (err) {
+                    lastError = err;
+                }
+                if (attempts < (retryAttempts || 0)) {
+                    ++attempts;
+                    await new Promise(resolve => setTimeout(resolve, retryDelay));
+                    retryMethod(attempts);
+                    return sendRequest();
+                }
+                errorMethod(lastError);
+                return Promise.reject(lastError);
+            };
+            return sendRequest();
+        }
+        async handleTimeout(timeout) {
+            timeout ??= 60000;
+            await new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error('Request timeout'));
+                }, timeout);
+            });
+            throw new Error('Request timeout');
+        }
+    }
+    exports.StorageMode = void 0;
+    (function (StorageMode) {
+        StorageMode[StorageMode["NetworkFirst"] = 0] = "NetworkFirst";
+        StorageMode[StorageMode["StorageFirst"] = 1] = "StorageFirst";
+        StorageMode[StorageMode["NetworkOnly"] = 2] = "NetworkOnly";
+        StorageMode[StorageMode["StorageAndUpdate"] = 3] = "StorageAndUpdate";
+    })(exports.StorageMode || (exports.StorageMode = {}));
+
+    exports.Cache = Cache;
+    exports.CancellationToken = CancellationToken;
+    exports.IndexedDbStorageProvider = IndexedDbStorageProvider;
+    exports.Request = Request;
+
+}));

package/lib/Request.umd.min.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("@jacraig/woodchuck")):"function"==typeof define&&define.amd?define(["exports","@jacraig/woodchuck"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).request={},e.woodchuck)}(this,(function(e,t){"use strict";class r{constructor(e,r,a){this.dbName=e,this.tables=r,this.version=a;const o=indexedDB.open(e,a);o.onupgradeneeded=e=>{if(this.database=e.target.result,this.database)for(const e of r)this.database.objectStoreNames.contains(e)&&this.database.deleteObjectStore(e),this.database.createObjectStore(e)},o.onsuccess=e=>{this.database=e.target.result},o.onerror=e=>{t.Logger.error("Failed to open the database:",e.target.error)}}openDatabase(){return new Promise(((e,r)=>{const a=indexedDB.open(this.dbName,this.version);a.onsuccess=t=>{this.database=t.target.result,e(this)},a.onerror=e=>{t.Logger.error("Failed to open the database:",e.target.error),r(new Error("Failed to open the database:"+e.target.error))}}))}add(e,r,a){return new Promise(((o,s)=>{if(!this.database)return t.Logger.error("Database connection is not open"),void s(new Error("Database connection is not open"));const i=this.database.transaction(e,"readwrite").objectStore(e).put(r,a);i.onsuccess=()=>{o()},i.onerror=e=>{t.Logger.error("Failed to add an object to the database: ",e.target.error),s(new Error("Failed to add an object to the database: "+e.target.error))}}))}remove(e,r){return new Promise(((a,o)=>{if(!this.database)return t.Logger.error("Database connection is not open"),void o(new Error("Database connection is not open"));const s=this.database.transaction(e,"readwrite").objectStore(e).delete(r);s.onsuccess=()=>{a()},s.onerror=e=>{t.Logger.error("Failed to remove an object from the database: ",e.target.error),o(new Error("Failed to remove an object from the database: "+e.target.error))}}))}getByKey(e,r){return new Promise(((a,o)=>{if(!this.database)return t.Logger.error("Database connection is not open"),void o(new Error("Database connection is not open"));const s=this.database.transaction(e,"readwrite").objectStore(e).get(r);s.onsuccess=e=>{a(e.target.result)},s.onerror=e=>{t.Logger.error("Failed to retrieve an object from the database: ",e.target.error),o(new Error("Failed to retrieve an object from the database: "+e.target.error))}}))}getKeys(e){return new Promise(((r,a)=>{if(!this.database)return t.Logger.error("Database connection is not open"),void a(new Error("Database connection is not open"));const o=this.database.transaction(e,"readwrite").objectStore(e).getAllKeys();o.onsuccess=e=>{r(e.target.result)},o.onerror=e=>{t.Logger.error("Failed to retrieve an object from the database: ",e.target.error),a(new Error("Failed to retrieve keys from the database: "+e.target.error))}}))}get(e,r){return new Promise(((a,o)=>{if(!this.database)return t.Logger.error("Database connection is not open"),void o(new Error("Database connection is not open"));const s=this.database.transaction(e,"readwrite").objectStore(e).get(r);s.onsuccess=e=>{a(e.target.result)},s.onerror=e=>{t.Logger.error("Failed to retrieve an object from the database: ",e.target.error),o(new Error("Failed to retrieve an object from the database: "+e.target.error))}}))}getAll(e,r){return new Promise(((a,o)=>{if(!this.database)return t.Logger.error("Database connection is not open"),void o(new Error("Database connection is not open"));const s=this.database.transaction(e,"readwrite").objectStore(e).getAll(r);s.onsuccess=e=>{a(e.target.result)},s.onerror=e=>{t.Logger.error("Failed to retrieve an object from the database: ",e.target.error),o(new Error("Failed to retrieve objects from the database: "+e.target.error))}}))}}class a{constructor(){this.database=new r("cacheStore",["cache","cacheEntryOptions"],1)}async clear(){await this.database.openDatabase();let e=await this.database.getAll("cacheEntryOptions"),t=await this.database.getAll("cache");for(let r=0;r<e.length;r++){let e=t[r];await this.remove(e.key)}return this}async getOptions(e){return await this.database.openDatabase(),this.database.getByKey("cacheEntryOptions",e)}async add(e,t,r){return await this.database.openDatabase(),await this.database.add("cache",e,t),await this.database.add("cacheEntryOptions",r,t),this}async remove(e){return await this.database.openDatabase(),await this.database.remove("cache",e),await this.database.remove("cacheEntryOptions",e),this}async get(e){return await this.database.openDatabase(),this.database.getByKey("cache",e)}async compact(){await this.database.openDatabase();let e=await this.database.getAll("cacheEntryOptions"),t=await this.database.getAll("cache"),r=(new Date).getTime();for(let a=0;a<e.length;a++){let o=e[a],s=t[a];0!=o.expirationTime&&(o.expirationTime<r&&await this.remove(s.key))}return this}}class o{constructor(){}static configure(e=new a){this.storageProvider??=globalThis.StorageProvider||e||new a,globalThis.StorageProvider=this.storageProvider}static async set(e,r,a={expirationTime:0,slidingExpirationTime:0,sliding:!1}){t.Logger.debug("Setting object in cache: ",{key:e,value:r,entryOptions:a}),this.configure(),await this.storageProvider.add(r,e,a)}static async get(e){t.Logger.debug("Getting object from cache: "+e),this.configure(),await this.storageProvider.compact();let r=await this.storageProvider.get(e);if(null==r)return r;let a=await this.storageProvider.getOptions(e);return a.sliding&&await this.set(e,r,{expirationTime:(new Date).getTime()+a.slidingExpirationTime,slidingExpirationTime:a.slidingExpirationTime,sliding:!0}),r}static async remove(e){t.Logger.debug("Removing object from cache: "+e),this.configure(),await this.storageProvider.remove(e)}static async clear(){t.Logger.debug("Clearing cache"),this.configure(),await this.storageProvider.clear()}}class s{constructor(r){this.options={method:"GET",url:"",headers:{},credentials:"same-origin",serializer:JSON.stringify,parser:e=>e.json(),success:e=>{t.Logger.debug("Request response from "+this.options.url+":",e)},error:e=>{t.Logger.error("Request error from "+this.options.url+":",e)},retry:e=>{t.Logger.debug("Request retry on "+this.options.url+":",{attempt:e})},storageMode:e.StorageMode.NetworkFirst,cacheKey:"",timeout:6e4,retryAttempts:3,retryDelay:1e3},this.abortController=null,this.options={...this.options,...r}}static get(e,t){return new s({method:"GET",url:e,data:t,cacheKey:e+JSON.stringify(t)}).withHeaders({Accept:"application/json"})}static post(t,r){return new s({method:"POST",url:t,data:r,cacheKey:t+JSON.stringify(r),storageMode:e.StorageMode.NetworkOnly}).withHeaders({"Content-Type":"application/json",Accept:"application/json"})}static put(t,r){return new s({method:"PUT",url:t,data:r,cacheKey:t+JSON.stringify(r),storageMode:e.StorageMode.NetworkOnly}).withHeaders({"Content-Type":"application/json",Accept:"application/json"})}static delete(t,r){return new s({method:"DELETE",url:t,data:r,cacheKey:t+JSON.stringify(r),storageMode:e.StorageMode.NetworkOnly}).withHeaders({Accept:"application/json"})}static ofType(e,t,r){return new s({method:e,url:t,data:r,cacheKey:t+JSON.stringify(r)}).withHeaders({Accept:"application/json"})}withAuthenticationProvider(e){return this.options.authenticationProvider=e,this}withHeaders(e){return this.options.headers={...this.options.headers,...e},this}withCancellationToken(e){return this.options.cancellationToken=e,this}withCredentials(e){return this.options.credentials=e,this}withSerializer(e){return this.options.serializer=e,this}withParser(e){return this.options.parser=e,this}onSuccess(e){return this.options.success=e??(e=>{t.Logger.debug("Request response:",e)}),this}onError(e){return this.options.error=e??(e=>{t.Logger.error("Request error:",e)}),this}onRetry(e){return this.options.retry=e??(e=>{t.Logger.debug("Request retry:",{attempt:e})}),this}withStorageMode(e){return this.options.storageMode=e,this}withCacheKey(e){return this.options.cacheKey=e,this}withTimeout(e){return this.options.timeout=e??6e4,this}withRetryAttempts(e){return this.options.retryAttempts=e,this}withRetryDelay(e){return this.options.retryDelay=e,this}abort(){return null==this.abortController||null==this.options.error||(this.abortController.abort(),this.options.error(new Error("The request was aborted."))),this}async send(){const{authenticationProvider:r,method:a,url:s,data:i,headers:n,credentials:c,serializer:d,parser:h,success:g,error:l,storageMode:u,cacheKey:b,timeout:p,retryAttempts:w,retryDelay:m,retry:y,cancellationToken:f}=this.options,v=new AbortController;this.abortController=v;let S=0,j=null,E=g||(e=>{t.Logger.debug("Request response from "+s+":",e)}),T=l||(e=>{t.Logger.error("Request error from "+s+":",e)}),P=d||JSON.stringify,D=h||(e=>e.json()),L=y||(e=>{t.Logger.debug("Request retry on "+s+":",{attempt:e})});const O=async()=>{if(u===e.StorageMode.StorageFirst||u===e.StorageMode.StorageAndUpdate){const t=await o.get(b||"");if(void 0!==t&&(E(t),u===e.StorageMode.StorageFirst))return t}if(!navigator.onLine){if(u===e.StorageMode.NetworkFirst){const e=await o.get(b||"");if(void 0!==e)return E(e),e}const t=new Error("System is offline");return T(t),Promise.reject(t)}try{const t=P(i);await(r?.authenticate(this));const d=await Promise.race([fetch(s,{method:a,credentials:c,headers:n,body:t,signal:v.signal}),this.handleTimeout(p)]);if(f?.canceled)return Promise.reject(new Error("The request was canceled."));if(d.status>=200&&d.status<300){const t=await D(d);return E(t),u!==e.StorageMode.NetworkOnly&&await o.set(b||"",t),t}j=new Error(d.statusText),401===d.status&&await(r?.authenticationFailed(this,d))}catch(e){j=e}return S<(w||0)?(++S,await new Promise((e=>setTimeout(e,m))),L(S),O()):(T(j),Promise.reject(j))};return O()}async handleTimeout(e){throw e??=6e4,await new Promise(((t,r)=>{setTimeout((()=>{r(new Error("Request timeout"))}),e)})),new Error("Request timeout")}}var i;e.StorageMode=void 0,(i=e.StorageMode||(e.StorageMode={}))[i.NetworkFirst=0]="NetworkFirst",i[i.StorageFirst=1]="StorageFirst",i[i.NetworkOnly=2]="NetworkOnly",i[i.StorageAndUpdate=3]="StorageAndUpdate",e.Cache=o,e.CancellationToken=class{constructor(){this.canceled=!1}},e.IndexedDbStorageProvider=a,e.Request=s}));

package/lib/declarations/Cache.d.ts

@@ -0,0 +1,33 @@
+export interface CacheEntryOptions {
+    expirationTime: number;
+    slidingExpirationTime: number;
+    sliding: boolean;
+}
+export interface StorageProvider {
+    add(obj: any, key: string, options: CacheEntryOptions): Promise<StorageProvider>;
+    remove(key: string): Promise<StorageProvider>;
+    get(key: string): Promise<any>;
+    getOptions(key: string): Promise<CacheEntryOptions>;
+    compact(): Promise<StorageProvider>;
+    clear(): Promise<StorageProvider>;
+}
+export declare class IndexedDbStorageProvider implements StorageProvider {
+    private database;
+    constructor();
+    clear(): Promise<StorageProvider>;
+    getOptions(key: string): Promise<CacheEntryOptions>;
+    add(obj: any, key: string, options: CacheEntryOptions): Promise<StorageProvider>;
+    remove(key: string): Promise<StorageProvider>;
+    get(key: string): Promise<any>;
+    compact(): Promise<StorageProvider>;
+}
+export declare class Cache {
+    private constructor();
+    static configure(storageProvider?: StorageProvider): void;
+    private static storageProvider;
+    static set(key: string, value: any, entryOptions?: CacheEntryOptions): Promise<void>;
+    static get(key: string): Promise<any>;
+    static remove(key: string): Promise<void>;
+    static clear(): Promise<void>;
+}
+//# sourceMappingURL=Cache.d.ts.map

package/lib/declarations/Cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../src/Cache.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,iBAAiB;IAE9B,cAAc,EAAE,MAAM,CAAC;IAEvB,qBAAqB,EAAE,MAAM,CAAC;IAE9B,OAAO,EAAE,OAAO,CAAC;CACpB;AAGD,MAAM,WAAW,eAAe;IAM5B,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAKjF,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAK9C,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAK/B,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAKpD,OAAO,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC;IAIpC,KAAK,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC;CACrC;AAGD,qBAAa,wBAAyB,YAAW,eAAe;IAE5D,OAAO,CAAC,QAAQ,CAAqB;;IASxB,KAAK,IAAI,OAAO,CAAC,eAAe,CAAC;IAcjC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;IASnD,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IAShF,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAU7C,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAQ9B,OAAO,IAAI,OAAO,CAAC,eAAe,CAAC;CAiBnD;AASD,qBAAa,KAAK;IAEd,OAAO;WAGO,SAAS,CAAC,eAAe,GAAE,eAAgD,GAAG,IAAI;IAMhG,OAAO,CAAC,MAAM,CAAC,eAAe,CAAkB;WAO5B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,YAAY,GAAE,iBAAmF,GAAG,OAAO,CAAC,IAAI,CAAC;WAS9I,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;WAsB9B,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAQlC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAK7C"}

package/lib/declarations/Database.d.ts

@@ -0,0 +1,15 @@
+export declare class DatabaseConnection {
+    private dbName;
+    private tables;
+    private version;
+    private database;
+    constructor(dbName: string, tables: string[], version: number);
+    openDatabase(): Promise<DatabaseConnection>;
+    add(table: string, obj: any, key: IDBValidKey): Promise<void>;
+    remove(table: string, key: IDBValidKey): Promise<void>;
+    getByKey(table: string, key: IDBValidKey): Promise<any>;
+    getKeys(table: string): Promise<IDBValidKey[]>;
+    get(table: string, query: string): Promise<any>;
+    getAll(table: string, query?: string): Promise<any[]>;
+}
+//# sourceMappingURL=Database.d.ts.map

package/lib/declarations/Database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Database.d.ts","sourceRoot":"","sources":["../../src/Database.ts"],"names":[],"mappings":"AAGA,qBAAa,kBAAkB;IAQf,OAAO,CAAC,MAAM;IAAU,OAAO,CAAC,MAAM;IAAY,OAAO,CAAC,OAAO;IAN7E,OAAO,CAAC,QAAQ,CAAwB;gBAMpB,MAAM,EAAE,MAAM,EAAU,MAAM,EAAE,MAAM,EAAE,EAAU,OAAO,EAAE,MAAM;IA4B9E,YAAY,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAoB3C,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAyB7D,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAyBtD,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC;IAyBvD,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAyB9C,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IA0B/C,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;CAqB/D"}

package/lib/declarations/Request.d.ts

@@ -0,0 +1,62 @@
+import { Cache, CacheEntryOptions, StorageProvider, IndexedDbStorageProvider } from "./Cache";
+declare class CancellationToken {
+    canceled: boolean;
+}
+interface AuthenticationProvider {
+    authenticate(request: Request): Promise<void>;
+    authenticationFailed(request: Request, reason: Response): Promise<void>;
+}
+interface RequestOptions {
+    authenticationProvider?: AuthenticationProvider;
+    cacheKey?: string;
+    cancellationToken?: CancellationToken;
+    credentials?: RequestCredentials;
+    data?: any;
+    error?: (reason: any) => void;
+    headers?: Record<string, string>;
+    method: string;
+    parser?: (response: Response) => Promise<any>;
+    retry?: (attempt: number) => void;
+    retryAttempts?: number;
+    retryDelay?: number;
+    serializer?: (data: any) => string;
+    storageMode?: StorageMode;
+    success?: (response: any) => void;
+    timeout?: number;
+    url: string;
+}
+declare class Request {
+    private options;
+    private abortController;
+    constructor(options: RequestOptions);
+    static get(url: string, data?: any): Request;
+    static post(url: string, data?: any): Request;
+    static put(url: string, data?: any): Request;
+    static delete(url: string, data?: any): Request;
+    static ofType(method: string, url: string, data?: any): Request;
+    withAuthenticationProvider(authenticationProvider: AuthenticationProvider): this;
+    withHeaders(headers: Record<string, string>): this;
+    withCancellationToken(cancellationToken: CancellationToken): this;
+    withCredentials(credentials: RequestCredentials): this;
+    withSerializer(serializer: (data: any) => string): this;
+    withParser(parser: (response: Response) => Promise<any>): this;
+    onSuccess(callback: (response: any) => void): this;
+    onError(callback: (reason: any) => void): this;
+    onRetry(callback: (attempt: number) => void): this;
+    withStorageMode(storageMode: StorageMode): this;
+    withCacheKey(cacheKey: string): this;
+    withTimeout(timeout?: number): this;
+    withRetryAttempts(retryAttempts: number): this;
+    withRetryDelay(retryDelay: number): this;
+    abort(): this;
+    send(): Promise<any>;
+    private handleTimeout;
+}
+declare enum StorageMode {
+    NetworkFirst = 0,
+    StorageFirst = 1,
+    NetworkOnly = 2,
+    StorageAndUpdate = 3
+}
+export { CancellationToken, AuthenticationProvider, RequestOptions, Request, StorageMode, Cache, CacheEntryOptions, StorageProvider, IndexedDbStorageProvider };
+//# sourceMappingURL=Request.d.ts.map

package/lib/declarations/Request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Request.d.ts","sourceRoot":"","sources":["../../src/Request.ts"],"names":[],"mappings":"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"}