@capacitor-community/sqlite 3.4.2-5 → 3.4.3-2

package/dist/plugin.cjs.js

@@ -420,19 +420,21 @@ class SQLiteDBConnection {
                     values: [],
                 });
             }
-            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];
-                    const resRowJson = {};
-                    for (const item of columnList) {
-                        resRowJson[item] = rowJson[item];
+            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];
+                        const resRowJson = {};
+                        for (const item of columnList) {
+                            resRowJson[item] = rowJson[item];
+                        }
+                        iosRes.push(resRowJson);
                     }
-                    iosRes.push(resRowJson);
+                    res = {};
+                    res['values'] = iosRes;
                 }
-                res = {};
-                res['values'] = iosRes;
             }
             return Promise.resolve(res);
         }
@@ -572,6 +574,15 @@ class SQLiteDBConnection {
             return Promise.reject(err);
         }
     }
+    async deleteExportedRows() {
+        try {
+            await this.sqlite.deleteExportedRows({ database: this.dbName });
+            return Promise.resolve();
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
     async executeTransaction(txn) {
         try {
             const ret = await this.sqlite.execute({
@@ -628,23 +639,6 @@ class SQLiteDBConnection {
         }
     }
 }
-/*
-if (Object.keys(res.values[0]).includes("ios_columns")) {
-  const columnList = res.values[0]["ios_columns"];
-  console.log(`in DBconnection query ${columnList}`);
-  const iosRes = []
-  for (let i = 1; i < res.values.length; i++) {
-    const rowJson = res.values[i];
-    const resRowJson = {};
-    for (const item of columnList) {
-      resRowJson[item] = rowJson[item];
-    }
-    console.log(`resRowJson: ${JSON.stringify(resRowJson)}`)
-    iosRes.push(resRowJson);
-  }
-  console.log(`iosRes ${JSON.stringify(iosRes)}`);
-}
-*/
 
 const CapacitorSQLite = core.registerPlugin('CapacitorSQLite', {
     web: () => Promise.resolve().then(function () { return web; }).then(m => new m.CapacitorSQLiteWeb()),
@@ -654,563 +648,351 @@ 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 deleteExportedRows(options) {
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            await this.jeepSqliteElement.deleteExportedRows(options);
+            return;
+        }
+        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.');
@@ -1223,11 +1005,38 @@ 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({
-  __proto__: null,
-  CapacitorSQLiteWeb: CapacitorSQLiteWeb
+    __proto__: null,
+    CapacitorSQLiteWeb: CapacitorSQLiteWeb
 });
 
 exports.CapacitorSQLite = CapacitorSQLite;