switch to dedicated source maps

static_src/WebStorage.ts

@@ -0,0 +1,80 @@
+/**
+ * @callback fetch
+ * @param {RequestInfo} resource
+ * @param {RequestInit} options
+ * @returns {Promise<Response>}
+ */
+
+export default class WebStorage {
+
+    #origin = new URL(import.meta.url).origin
+    #auth_provider: import('@twurple/auth').AuthProvider = null;
+    #cache: Cache = null
+    #fetch: typeof globalThis.fetch = null
+
+    /**
+     * Creates a fetch request wrapper that returns cached responses when the server can't be reached.
+     * When only a path is provided, the origin defaults to the same origin this module was loaded from.
+     * When the origin matches this script, authorization headers are added automatically.
+     * You can also use this for GET requests to any orgigin, but other methods may have unknown behavior.
+     * @param {import('@twurple/auth').AuthProvider} auth_provider used to add the authentication header to requests for web storage
+     * @param {fetch} fetch defaults to `globalThis.fetch`, allows you to further customize fetch behavior via chaining, for example with `fetch-retry`
+     */
+    constructor(auth_provider: import('@twurple/auth').AuthProvider, fetch: typeof globalThis.fetch = (resource,options)=>{return globalThis.fetch(resource,options)}) {
+        this.#fetch = fetch
+        this.#auth_provider = auth_provider
+        auth_provider.getAccessTokenForUser(undefined)
+            .then(token => caches.open(token.userId + '/' + auth_provider.clientId))
+            .then(cache => this.#cache = cache)
+    }
+
+    /**
+     * 
+     * @param {String | URL} resource 
+     * @param {RequestInit} options 
+     */
+    async fetch(resource: string | URL, options: RequestInit={}) {
+        resource = new URL(resource, this.#origin)
+        if (resource.origin == this.#origin) {
+            const token = await this.#auth_provider.getAccessTokenForUser(undefined)
+            if (!options.headers) {
+                options.headers = {}
+            }
+            options.headers['authorization'] = 'OAuth ' + token.accessToken
+        }
+        if ('method' in options) {
+            switch (options.method) {
+                case 'PUT':
+                case 'POST': {
+                    const response = await this.#fetch(resource, options)
+                    if (!response.ok) {
+                        return response
+                    }
+                    const blob = await new Request(resource, options).blob()
+                    this.#cache.put(resource, new Response(blob))
+                    return response
+                }
+                case 'DELETE': {
+                    const response = await this.#fetch(resource, options)
+                    if (!response.ok) {
+                        return response
+                    }
+                    this.#cache.delete(resource)
+                    return response
+                }
+            }
+        }
+        return this.#fetch(resource, options)
+            .then(async response => {
+                if (response.status >= 500) {
+                    throw new Error(response.statusText + '\n' + await response.text())
+                }
+                this.#cache.put(resource, response.clone())
+                return response
+            }).catch(error => {
+                console.warn(error)
+                return this.#cache.match(resource)
+            }
+        )
+    }
+}