did-session/dist/sessionStore.js

Manage user DIDs in a web environment

function _check_private_redeclaration(obj, privateCollection) {
    if (privateCollection.has(obj)) {
        throw new TypeError("Cannot initialize the same private elements twice on an object");
    }
}
function _class_apply_descriptor_get(receiver, descriptor) {
    if (descriptor.get) {
        return descriptor.get.call(receiver);
    }
    return descriptor.value;
}
function _class_apply_descriptor_set(receiver, descriptor, value) {
    if (descriptor.set) {
        descriptor.set.call(receiver, value);
    } else {
        if (!descriptor.writable) {
            throw new TypeError("attempted to set read only private field");
        }
        descriptor.value = value;
    }
}
function _class_extract_field_descriptor(receiver, privateMap, action) {
    if (!privateMap.has(receiver)) {
        throw new TypeError("attempted to " + action + " private field on non-instance");
    }
    return privateMap.get(receiver);
}
function _class_private_field_get(receiver, privateMap) {
    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
    return _class_apply_descriptor_get(receiver, descriptor);
}
function _class_private_field_init(obj, privateMap, value) {
    _check_private_redeclaration(obj, privateMap);
    privateMap.set(obj, value);
}
function _class_private_field_set(receiver, privateMap, value) {
    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
    _class_apply_descriptor_set(receiver, descriptor, value);
    return value;
}
var _db = /*#__PURE__*/ new WeakMap();
export class SessionStore {
    static async create() {
        if (typeof globalThis.indexedDB === 'undefined') {
            throw new Error('SessionStore is only supported in the browser');
        }
        const request = indexedDB.open('did-session', 1);
        request.onupgradeneeded = (event)=>{
            const db = event.target.result;
            db.createObjectStore('sessions');
        };
        const db = await new Promise((resolve, reject)=>{
            request.onsuccess = ()=>resolve(request.result);
            request.onerror = ()=>reject(request.error);
        });
        return new SessionStore(db);
    }
    async get(account) {
        const store = _class_private_field_get(this, _db).transaction('sessions', 'readonly').objectStore('sessions');
        const request = store.get(account.toString());
        return new Promise((resolve, reject)=>{
            request.onsuccess = ()=>resolve(request.result);
            request.onerror = ()=>reject(request.error);
        });
    }
    async set(account, session) {
        const store = _class_private_field_get(this, _db).transaction('sessions', 'readwrite').objectStore('sessions');
        const request = store.put(session, account.toString());
        return new Promise((resolve, reject)=>{
            request.onsuccess = ()=>resolve();
            request.onerror = ()=>reject(request.error);
        });
    }
    async remove(accountId) {
        const store = _class_private_field_get(this, _db).transaction('sessions', 'readwrite').objectStore('sessions');
        const request = store.delete(accountId.toString());
        return new Promise((resolve, reject)=>{
            request.onsuccess = ()=>resolve();
            request.onerror = ()=>reject(request.error);
        });
    }
    close() {
        _class_private_field_get(this, _db).close();
    }
    constructor(db){
        _class_private_field_init(this, _db, {
            writable: true,
            value: void 0
        });
        _class_private_field_set(this, _db, db);
    }
}