@capacitor-community/sqlite 3.4.2-4 → 3.4.3-1

package/dist/plugin.cjs.js

@@ -412,10 +412,17 @@ class SQLiteDBConnection {
                     statement: statement,
                     values: values,
                 });
-                console.log(`&&&& in query res start: ${JSON.stringify(res)}`);
-                console.log(`&&&& in query: ${res.values[0]["ios_columns"]}`);
-                if (Object.keys(res.values[0]).includes("ios_columns")) {
-                    const columnList = res.values[0]["ios_columns"];
+            }
+            else {
+                res = await this.sqlite.query({
+                    database: this.dbName,
+                    statement: statement,
+                    values: [],
+                });
+            }
+            if (res && typeof res.values[0] === 'object') {
+                if (Object.keys(res.values[0]).includes('ios_columns')) {
+                    const columnList = res.values[0]['ios_columns'];
                     const iosRes = [];
                     for (let i = 1; i < res.values.length; i++) {
                         const rowJson = res.values[i];
@@ -425,16 +432,9 @@ class SQLiteDBConnection {
                         }
                         iosRes.push(resRowJson);
                     }
-                    res = iosRes;
+                    res = {};
+                    res['values'] = iosRes;
                 }
-                console.log(`&&&& in query res final: ${JSON.stringify(res)}`);
-            }
-            else {
-                res = await this.sqlite.query({
-                    database: this.dbName,
-                    statement: statement,
-                    values: [],
-                });
             }
             return Promise.resolve(res);
         }
@@ -656,563 +656,340 @@ const CapacitorSQLite = core.registerPlugin('CapacitorSQLite', {
 class CapacitorSQLiteWeb extends core.WebPlugin {
     constructor() {
         super(...arguments);
-        this.sqliteEl = null;
-        this.isStoreOpen = false;
+        this.jeepSqliteElement = null;
+        this.isWebStoreOpen = false;
     }
     async initWebStore() {
         await customElements.whenDefined('jeep-sqlite');
-        this.sqliteEl = document.querySelector('jeep-sqlite');
-        if (this.sqliteEl != null) {
-            this.sqliteEl.addEventListener('jeepSqliteImportProgress', (event) => {
-                this.notifyListeners('sqliteImportProgressEvent', event.detail);
-            });
-            this.sqliteEl.addEventListener('jeepSqliteExportProgress', (event) => {
-                this.notifyListeners('sqliteExportProgressEvent', event.detail);
-            });
-            if (!this.isStoreOpen)
-                this.isStoreOpen = await this.sqliteEl.isStoreOpen();
-            return Promise.resolve();
-        }
-        else {
-            return Promise.reject('InitWeb: this.sqliteEl is null');
-        }
+        this.jeepSqliteElement = document.querySelector('jeep-sqlite');
+        this.ensureJeepSqliteIsAvailable();
+        this.jeepSqliteElement.addEventListener('jeepSqliteImportProgress', (event) => {
+            this.notifyListeners('sqliteImportProgressEvent', event.detail);
+        });
+        this.jeepSqliteElement.addEventListener('jeepSqliteExportProgress', (event) => {
+            this.notifyListeners('sqliteExportProgressEvent', event.detail);
+        });
+        if (!this.isWebStoreOpen) {
+            this.isWebStoreOpen = await this.jeepSqliteElement.isStoreOpen();
+        }
+        return;
     }
     async saveToStore(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    await this.sqliteEl.saveToStore(options);
-                    return Promise.resolve();
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            await this.jeepSqliteElement.saveToStore(options);
+            return;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async echo(options) {
-        if (this.sqliteEl != null) {
-            const echo = await this.sqliteEl.echo(options);
-            return echo;
-        }
-        else {
-            throw this.unimplemented('Not implemented on web.');
-        }
-    }
-    async isSecretStored() {
-        throw this.unimplemented('Not implemented on web.');
-    }
-    async setEncryptionSecret(options) {
-        console.log('setEncryptionSecret', options);
-        throw this.unimplemented('Not implemented on web.');
-    }
-    async changeEncryptionSecret(options) {
-        console.log('changeEncryptionSecret', options);
-        throw this.unimplemented('Not implemented on web.');
-    }
-    async getNCDatabasePath(options) {
-        console.log('getNCDatabasePath', options);
-        throw this.unimplemented('Not implemented on web.');
-    }
-    async createNCConnection(options) {
-        console.log('createNCConnection', options);
-        throw this.unimplemented('Not implemented on web.');
-    }
-    async closeNCConnection(options) {
-        console.log('closeNCConnection', options);
-        throw this.unimplemented('Not implemented on web.');
-    }
-    async isNCDatabase(options) {
-        console.log('isNCDatabase', options);
-        throw this.unimplemented('Not implemented on web.');
+        this.ensureJeepSqliteIsAvailable();
+        const echoResult = await this.jeepSqliteElement.echo(options);
+        return echoResult;
     }
     async createConnection(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    await this.sqliteEl.createConnection(options);
-                    return Promise.resolve();
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            await this.jeepSqliteElement.createConnection(options);
+            return;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async open(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    await this.sqliteEl.open(options);
-                    return Promise.resolve();
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            await this.jeepSqliteElement.open(options);
+            return;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async closeConnection(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    await this.sqliteEl.closeConnection(options);
-                    return Promise.resolve();
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            await this.jeepSqliteElement.closeConnection(options);
+            return;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
-    async getUrl() {
-        throw this.unimplemented('Not implemented on web.');
-    }
     async getVersion(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    const ret = await this.sqliteEl.getVersion(options);
-                    return Promise.resolve(ret);
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const versionResult = await this.jeepSqliteElement.getVersion(options);
+            return versionResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async checkConnectionsConsistency(options) {
-        if (this.sqliteEl != null) {
-            try {
-                const ret = await this.sqliteEl.checkConnectionsConsistency(options);
-                return Promise.resolve(ret);
-            }
-            catch (err) {
-                return Promise.reject(`${err}`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        try {
+            const consistencyResult = await this.jeepSqliteElement.checkConnectionsConsistency(options);
+            return consistencyResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async close(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    await this.sqliteEl.close(options);
-                    return Promise.resolve();
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            await this.jeepSqliteElement.close(options);
+            return;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async getTableList(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    const res = await this.sqliteEl.getTableList(options);
-                    return Promise.resolve(res);
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const tableListResult = await this.jeepSqliteElement.getTableList(options);
+            return tableListResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async execute(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    const ret = await this.sqliteEl.execute(options);
-                    return Promise.resolve(ret);
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const executeResult = await this.jeepSqliteElement.execute(options);
+            return executeResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async executeSet(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    const ret = await this.sqliteEl.executeSet(options);
-                    return Promise.resolve(ret);
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const executeResult = await this.jeepSqliteElement.executeSet(options);
+            return executeResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async run(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    const ret = await this.sqliteEl.run(options);
-                    return Promise.resolve(ret);
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const runResult = await this.jeepSqliteElement.run(options);
+            return runResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async query(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    const ret = await this.sqliteEl.query(options);
-                    return Promise.resolve(ret);
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const queryResult = await this.jeepSqliteElement.query(options);
+            return queryResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async isDBExists(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    const ret = await this.sqliteEl.isDBExists(options);
-                    return Promise.resolve(ret);
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const dbExistsResult = await this.jeepSqliteElement.isDBExists(options);
+            return dbExistsResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async isDBOpen(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    const ret = await this.sqliteEl.isDBOpen(options);
-                    return Promise.resolve(ret);
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const isDBOpenResult = await this.jeepSqliteElement.isDBOpen(options);
+            return isDBOpenResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async isDatabase(options) {
-        if (this.sqliteEl != null) {
-            if (!this.isStoreOpen)
-                this.isStoreOpen = await this.sqliteEl.isStoreOpen();
-            if (this.isStoreOpen) {
-                try {
-                    const ret = await this.sqliteEl.isDatabase(options);
-                    return Promise.resolve(ret);
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const isDatabaseResult = await this.jeepSqliteElement.isDatabase(options);
+            return isDatabaseResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async isTableExists(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    const ret = await this.sqliteEl.isTableExists(options);
-                    return Promise.resolve(ret);
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const tableExistsResult = await this.jeepSqliteElement.isTableExists(options);
+            return tableExistsResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async deleteDatabase(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    await this.sqliteEl.deleteDatabase(options);
-                    return Promise.resolve();
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            await this.jeepSqliteElement.deleteDatabase(options);
+            return;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async isJsonValid(options) {
-        if (this.sqliteEl != null) {
-            if (!this.isStoreOpen)
-                this.isStoreOpen = await this.sqliteEl.isStoreOpen();
-            if (this.isStoreOpen) {
-                try {
-                    const ret = await this.sqliteEl.isJsonValid(options);
-                    return Promise.resolve(ret);
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const isJsonValidResult = await this.jeepSqliteElement.isJsonValid(options);
+            return isJsonValidResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async importFromJson(options) {
-        if (this.sqliteEl != null) {
-            if (!this.isStoreOpen)
-                this.isStoreOpen = await this.sqliteEl.isStoreOpen();
-            if (this.isStoreOpen) {
-                try {
-                    const ret = await this.sqliteEl.importFromJson(options);
-                    return Promise.resolve(ret);
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const importFromJsonResult = await this.jeepSqliteElement.importFromJson(options);
+            return importFromJsonResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async exportToJson(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    const ret = await this.sqliteEl.exportToJson(options);
-                    return Promise.resolve(ret);
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const exportToJsonResult = await this.jeepSqliteElement.exportToJson(options);
+            return exportToJsonResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async createSyncTable(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    const ret = await this.sqliteEl.createSyncTable(options);
-                    return Promise.resolve(ret);
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const createSyncTableResult = await this.jeepSqliteElement.createSyncTable(options);
+            return createSyncTableResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async setSyncDate(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    await this.sqliteEl.setSyncDate(options);
-                    return Promise.resolve();
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            await this.jeepSqliteElement.setSyncDate(options);
+            return;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async getSyncDate(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    const ret = await this.sqliteEl.getSyncDate(options);
-                    return Promise.resolve(ret);
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const getSyncDateResult = await this.jeepSqliteElement.getSyncDate(options);
+            return getSyncDateResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async addUpgradeStatement(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    await this.sqliteEl.addUpgradeStatement(options);
-                    return Promise.resolve();
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            await this.jeepSqliteElement.addUpgradeStatement(options);
+            return;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async copyFromAssets(options) {
-        if (this.sqliteEl != null) {
-            if (this.isStoreOpen) {
-                try {
-                    await this.sqliteEl.copyFromAssets(options);
-                    return Promise.resolve();
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            await this.jeepSqliteElement.copyFromAssets(options);
+            return;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async getDatabaseList() {
-        if (this.sqliteEl != null) {
-            if (!this.isStoreOpen)
-                this.isStoreOpen = await this.sqliteEl.isStoreOpen();
-            if (this.isStoreOpen) {
-                try {
-                    const ret = await this.sqliteEl.getDatabaseList();
-                    return Promise.resolve(ret);
-                }
-                catch (err) {
-                    return Promise.reject(`${err}`);
-                }
-            }
-            else {
-                return Promise.reject(`Store "jeepSqliteStore" failed to open`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const databaseListResult = await this.jeepSqliteElement.getDatabaseList();
+            return databaseListResult;
         }
-        else {
-            throw this.unimplemented('Not implemented on web.');
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
+    /**
+     * Checks if the `jeep-sqlite` element is present in the DOM.
+     * If it's not in the DOM, this method throws an Error.
+     *
+     * Attention: This will always fail, if the `intWebStore()` method wasn't called before.
+     */
+    ensureJeepSqliteIsAvailable() {
+        if (this.jeepSqliteElement === null) {
+            throw new Error(`The jeep-sqlite element is not present in the DOM! Please check the @capacitor-community/sqlite documentation for instructions regarding the web platform.`);
+        }
+    }
+    ensureWebstoreIsOpen() {
+        if (!this.isWebStoreOpen) {
+            /**
+             * if (!this.isWebStoreOpen)
+              this.isWebStoreOpen = await this.jeepSqliteElement.isStoreOpen();
+             */
+            throw new Error('WebStore is not open yet. You have to call "initWebStore()" first.');
+        }
+    }
+    ////////////////////////////////////
+    ////// UNIMPLEMENTED METHODS
+    ////////////////////////////////////
+    async getUrl() {
+        throw this.unimplemented('Not implemented on web.');
+    }
     async getMigratableDbList(options) {
         console.log('getMigratableDbList', options);
         throw this.unimplemented('Not implemented on web.');
@@ -1225,6 +1002,33 @@ class CapacitorSQLiteWeb extends core.WebPlugin {
         console.log('deleteOldDatabases', options);
         throw this.unimplemented('Not implemented on web.');
     }
+    async isSecretStored() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async setEncryptionSecret(options) {
+        console.log('setEncryptionSecret', options);
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async changeEncryptionSecret(options) {
+        console.log('changeEncryptionSecret', options);
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async getNCDatabasePath(options) {
+        console.log('getNCDatabasePath', options);
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async createNCConnection(options) {
+        console.log('createNCConnection', options);
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async closeNCConnection(options) {
+        console.log('closeNCConnection', options);
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async isNCDatabase(options) {
+        console.log('isNCDatabase', options);
+        throw this.unimplemented('Not implemented on web.');
+    }
 }
 
 var web = /*#__PURE__*/Object.freeze({