async function getFullSettings() {
    var settings = await getLocalSettings();
    var configureSettings = Object.assign(helpers.deepCopy(settings), {
        defaultStore: {},
    });
    var response = await hostAction(configureSettings, "configure");

    if (response.status != "ok") {
        settings.hostError = response;
    }
    settings.version = response.version;
    const EDIT_VERSION = 3 * 1000000 + 1 * 1000 + 0;

    // host capabilities
    settings.caps.save = settings.version >= EDIT_VERSION;
    settings.caps.delete = settings.version >= EDIT_VERSION;
    settings.caps.tree = settings.version >= EDIT_VERSION;

    // Fill store settings, only makes sense if 'configure' succeeded
    if (response.status === "ok") {
        if (Object.keys(settings.stores).length > 0) {
            // there are user-configured stores present
            for (var storeId in settings.stores) {
                if (response.data.storeSettings.hasOwnProperty(storeId)) {
                    var fileSettings = JSON.parse(response.data.storeSettings[storeId]);
                    if (typeof settings.stores[storeId].settings !== "object") {
                        settings.stores[storeId].settings = {};
                    }
                    var storeSettings = settings.stores[storeId].settings;
                    for (var settingKey in fileSettings) {
                        if (!storeSettings.hasOwnProperty(settingKey)) {
                            storeSettings[settingKey] = fileSettings[settingKey];
                        }
                    }
                }
            }
        } else {
            // no user-configured stores, so use the default store
            settings.stores.default = {
                id: "default",
                name: "pass",
                path: response.data.defaultStore.path,
            };
            var fileSettings = JSON.parse(response.data.defaultStore.settings);
            if (typeof settings.stores.default.settings !== "object") {
                settings.stores.default.settings = {};
            }
            var storeSettings = settings.stores.default.settings;
            for (var settingKey in fileSettings) {
                if (!storeSettings.hasOwnProperty(settingKey)) {
                    storeSettings[settingKey] = fileSettings[settingKey];
                }
            }
        }
    }

    // Fill recent data
    for (var storeId in settings.stores) {
        const whenKey = `recent:${storeId}`;
        var when = await chrome.storage.local.get([whenKey]);
        if (when && Object.prototype.hasOwnProperty.call(when, whenKey)) {
            try {
                settings.stores[storeId].when = JSON.parse(when[whenKey]);
            } catch (err) {
                console.error(
                    `getFullSettings() error fill stores recent data (${whenKey})`,
                    err,
                    when
                );
            }
        } else {
            settings.stores[storeId].when = 0;
        }
    }
    const recentKey = "recent";
    const recent = await chrome.storage.local.get(recentKey);
    if (recent && Object.prototype.hasOwnProperty.call(recent, recentKey)) {
        try {
            settings.recent = JSON.parse(recent[recentKey]);
        } catch (err) {
            console.error(`getFullSettings() error recent`, err, recent);
        }
    } else {
        settings.recent = {};
    }

    // Fill current tab info
    try {
        settings.tab = (await chrome.tabs.query({ active: true, currentWindow: true }))[0];
        if (settings.tab) {
            let originInfo = new BrowserpassURL(settings.tab.url);
            settings.origin = originInfo.origin;
        }
    } catch (e) {
        console.error(`getFullsettings() failure getting tab: ${e}`, { e });
    }

    // check for auth url
    try {
        if (settings.tab) {
            const authUrl = helpers.parseAuthUrl(settings.tab.url);
            if (authUrl && currentAuthRequest && currentAuthRequest.url) {
                settings.authRequested = authUrl.startsWith(
                    helpers.parseAuthUrl(currentAuthRequest.url)
                );
            }
        }
    } catch (e) {
        console.error(`getFullsettings() failure parsing auth url: ${e}`, { e });
    }

    return settings;
}
Get full settings from the extension and host application

@since 3.0.0

@return object Full settings object