Cordova iOS app using IndexedDB database size calculation without crashing app

I have a cordova app for iOS in which I'm using indexedDB to store significant amounts of data in separate stores in one database.

I want to inform the user of the amount of space being used by the app in this way, partly as the limit for indexedDB seems to be unclear/different on different devices, and I'd like to use it to see where the usage is at at point of failure, and also as a way to warn the user that they need to manage the data they're storing offline before it becomes a problem (although I know I can capture this is the transaction abort event - I just have no idea what the limit is!)

In development I've been using the function below in the browser (I have the browser platform added, just for development) which has worked well:

function showIndexedDbSize(db_name) {
    "use strict";
    var this_db;
    var storesizes = new Array();

    function openDatabase() {
        return new Promise(function(resolve, reject) {
            var request = window.indexedDB.open(db_name);
            request.onsuccess = function (event) {
                this_db = event.target.result;
                resolve(this_db.objectStoreNames);
            };      
        });
    }

    function getObjectStoreData(storename) {
        return new Promise(function(resolve, reject) {
            var trans = this_db.transaction(storename, IDBTransaction.READ_ONLY);
            var store = trans.objectStore(storename);
            var items = [];
            trans.oncomplete = function(evt) {
                var szBytes = toSize(items);
                var szMBytes = (szBytes / 1024 / 1024).toFixed(2);
                storesizes.push({'Store Name': storename, 'Items': items.length,  'Size': szMBytes + 'MB (' + szBytes + ' bytes)'});
                resolve();
            };

            var cursorRequest = store.openCursor();
            cursorRequest.onerror = function(error) {
                reject(error);
            };
            cursorRequest.onsuccess = function(evt) {                   
                var cursor = evt.target.result;
                if (cursor) {
                    items.push(cursor.value);
                    cursor.continue();
                }
            }
        });
    }

    function toSize(items) {
        var size = 0;
        for (var i = 0; i < items.length; i++) {
            var objectSize = JSON.stringify(items[i]).length;
            size += objectSize * 2;
        }
        return size;
    }

    openDatabase().then(function(stores) {
        var PromiseArray = [];
        for (var i=0; i < stores.length; i++) {
            PromiseArray.push(getObjectStoreData(stores[i]));    
        }
        Promise.all(PromiseArray).then(function() {
            this_db.close();
            console.table(storesizes);
        });
    });
};

It works well on the device too when the stores total <150MB, or thereabouts (there isn't a clear threshold), but it uses JSON.stringify to serialize the objects in order to count the bytes, and the process of doing this as the database grows larger on the device forces the app to restart. I'm watching the memory usage in XCode and it doesn't peak at all. Nothing. It hovers between 25 and 30MB whatever you do, not just this, which seems ok to me. The CPU is also <5%. The energy usage is high, but I'm not sure this would affect the app negatively, just drain the battery faster (unless I've misunderstood something). So I'm not sure why it's forcing an ugly restart. In my endless googling I've learnt that JSON.parse and JSON.stringify are very hungry processes, which is why I switched to indexedDB in the first place as it allows the storage of objects, avoiding these processes entirely.

My questions are as follows:

1. Is there a way to amend the function to slow it down (it doesn't need to be fast, just reliable!) to prevent the restart?
2. Why would the app refresh if there is not discernible pressure on the memory in XCode? Or is this not a very good way of detecting this sort of thing? Is there some hidden garbage collection problem in the function (I'm a noob when it comes to GC generally, but there doesn't seem to be any leaks in the app)
3. Is there a better way to show the usage of the database that would avoid this problem? Everything I find always relies on these JSON processes and the navigator.storage Web API doesn't appear to be supported on the cordova iOS platform (which is a real shame as it works amazingly on the browser! Gah!)

Any suggestions/thoughts massively appreciated!

from Cordova iOS app using IndexedDB database size calculation without crashing app