Publish Vulpes Preview 15 sources for desktop, Android and Tundra

Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.

adapters/datastores-indexeddb.mjs

@@ -0,0 +1,72 @@
+export class DataStoresIndexedDB {
+  constructor(factory, keyRange, uuid) {
+    Object.assign(this, { factory, keyRange, uuid });
+  }
+  open() {
+    return (this.database ||= new Promise((resolve, reject) => {
+      const request = this.factory.open('vulpes-datastores-v1', 1);
+      request.onupgradeneeded = () => {
+        request.result.createObjectStore('values');
+        request.result.createObjectStore('revisions');
+      };
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        request.result.onversionchange = () => request.result.close();
+        resolve(request.result);
+      };
+    }));
+  }
+  async run(key, operation, args) {
+    const db = await this.open();
+    return new Promise((resolve, reject) => {
+      const write = ['add', 'put', 'remove', 'clear'].includes(operation);
+      const tx = db.transaction(['values', 'revisions'], write ? 'readwrite' : 'readonly');
+      const store = tx.objectStore('values'),
+        revisions = tx.objectStore('revisions');
+      const range = this.keyRange.bound([key], [key, []]);
+      let value,
+        revisionId = '',
+        entries = [];
+      tx.onabort = () => reject(tx.error || new Error('TRANSACTION_ABORTED'));
+      tx.onerror = () => {};
+      tx.oncomplete = () => resolve({ value, revisionId });
+      if (operation === 'get') {
+        value = [];
+        args.forEach((id, index) => {
+          store.get([key, id]).onsuccess = (event) => {
+            if (args.length === 1) value = event.target.result;
+            else value[index] = event.target.result;
+          };
+        });
+      } else if (operation === 'snapshot') {
+        revisions.get(key).onsuccess = (event) => {
+          revisionId = event.target.result || '';
+        };
+        store.openCursor(range).onsuccess = (event) => {
+          const cursor = event.target.result;
+          if (cursor) {
+            entries.push({ id: cursor.key[1], data: cursor.value });
+            cursor.continue();
+          } else value = { revisionId, entries };
+        };
+      } else if (operation === 'length') {
+        store.count(range).onsuccess = (event) => {
+          value = event.target.result;
+        };
+      } else if (write) {
+        revisionId = this.uuid();
+        revisions.put(revisionId, key);
+        if (operation === 'clear') store.delete(range);
+        else if (operation === 'remove') {
+          store.count([key, args[0]]).onsuccess = (event) => {
+            value = event.target.result > 0;
+          };
+          store.delete([key, args[0]]);
+        } else {
+          value = args[1] === undefined ? this.uuid() : args[1];
+          store[operation === 'add' ? 'add' : 'put'](args[0], [key, value]);
+        }
+      } else tx.abort();
+    });
+  }
+}

adapters/indexeddb.mjs

@@ -0,0 +1,39 @@
+// Web-standard storage adapter. Schema version is independent of Gecko version.
+export class IndexedDBStorage {
+  constructor(database) {
+    this.database = database;
+  }
+  static open(name = 'vulpes-services-v1') {
+    return new Promise((resolve, reject) => {
+      const req = indexedDB.open(name, 1);
+      req.onupgradeneeded = () => req.result.createObjectStore('settings');
+      req.onsuccess = () => {
+        const db = req.result;
+        db.onversionchange = () => db.close();
+        resolve(new IndexedDBStorage(db));
+      };
+      req.onerror = () => reject(req.error);
+      req.onblocked = () => reject(new Error('DATABASE_BLOCKED'));
+    });
+  }
+  get(key) {
+    return new Promise((resolve, reject) => {
+      const tx = this.database.transaction('settings', 'readonly');
+      const req = tx.objectStore('settings').get(key);
+      tx.oncomplete = () => resolve(req.result);
+      tx.onabort = () => reject(tx.error);
+    });
+  }
+  setMany(entries) {
+    return new Promise((resolve, reject) => {
+      const tx = this.database.transaction('settings', 'readwrite');
+      tx.oncomplete = () => resolve();
+      tx.onabort = () => reject(tx.error);
+      const store = tx.objectStore('settings');
+      for (const [key, value] of entries) store.put(value, key);
+    });
+  }
+  close() {
+    this.database.close();
+  }
+}