dexie-cloud-addon 4.0.1-beta.46 → 4.0.1-beta.47

package/dist/umd/dexie-cloud-addon.js

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.0.1-beta.46, Sat Aug 05 2023
+ * Version 4.0.1-beta.47, Fri Oct 13 2023
  *
  * https://dexie.org
  *
@@ -1924,58 +1924,6 @@
                 identity;
     }
 
-    var TimeoutError = createErrorClass(function (_super) {
-        return function TimeoutErrorImpl(info) {
-            if (info === void 0) { info = null; }
-            _super(this);
-            this.message = 'Timeout has occurred';
-            this.name = 'TimeoutError';
-            this.info = info;
-        };
-    });
-    function timeout(config, schedulerArg) {
-        var _a = (isValidDate(config) ? { first: config } : typeof config === 'number' ? { each: config } : config), first = _a.first, each = _a.each, _b = _a.with, _with = _b === void 0 ? timeoutErrorFactory : _b, _c = _a.scheduler, scheduler = _c === void 0 ? schedulerArg !== null && schedulerArg !== void 0 ? schedulerArg : asyncScheduler : _c, _d = _a.meta, meta = _d === void 0 ? null : _d;
-        if (first == null && each == null) {
-            throw new TypeError('No timeout provided.');
-        }
-        return operate(function (source, subscriber) {
-            var originalSourceSubscription;
-            var timerSubscription;
-            var lastValue = null;
-            var seen = 0;
-            var startTimer = function (delay) {
-                timerSubscription = executeSchedule(subscriber, scheduler, function () {
-                    try {
-                        originalSourceSubscription.unsubscribe();
-                        innerFrom(_with({
-                            meta: meta,
-                            lastValue: lastValue,
-                            seen: seen,
-                        })).subscribe(subscriber);
-                    }
-                    catch (err) {
-                        subscriber.error(err);
-                    }
-                }, delay);
-            };
-            originalSourceSubscription = source.subscribe(createOperatorSubscriber(subscriber, function (value) {
-                timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.unsubscribe();
-                seen++;
-                subscriber.next((lastValue = value));
-                each > 0 && startTimer(each);
-            }, undefined, undefined, function () {
-                if (!(timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.closed)) {
-                    timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.unsubscribe();
-                }
-                lastValue = null;
-            }));
-            !seen && startTimer(first != null ? (typeof first === 'number' ? first : +first - scheduler.now()) : each);
-        });
-    }
-    function timeoutErrorFactory(info) {
-        throw new TimeoutError(info);
-    }
-
     //const hasSW = 'serviceWorker' in navigator;
     let hasComplainedAboutSyncEvent = false;
     function registerSyncEvent(db, purpose) {
@@ -2036,6 +1984,7 @@
 
     function triggerSync(db, purpose) {
         if (db.cloud.usingServiceWorker) {
+            console.debug('registering sync event');
             registerSyncEvent(db, purpose);
         }
         else {
@@ -2067,14 +2016,24 @@
             return btoa(String.fromCharCode.apply(null, ArrayBuffer.isView(b) ? b : new Uint8Array(b)));
         };
 
+    class TokenErrorResponseError extends Error {
+        constructor({ title, message, messageCode, messageParams, }) {
+            super(message);
+            this.name = 'TokenErrorResponseError';
+            this.title = title;
+            this.messageCode = messageCode;
+            this.messageParams = messageParams;
+        }
+    }
+
     function interactWithUser(userInteraction, req) {
         return new Promise((resolve, reject) => {
-            const interactionProps = Object.assign(Object.assign({}, req), { onSubmit: (res) => {
+            const interactionProps = Object.assign(Object.assign({ submitLabel: 'Submit', cancelLabel: 'Cancel' }, req), { onSubmit: (res) => {
                     userInteraction.next(undefined);
                     resolve(res);
                 }, onCancel: () => {
                     userInteraction.next(undefined);
-                    reject(new Dexie__default["default"].AbortError("User cancelled"));
+                    reject(new Dexie__default["default"].AbortError('User cancelled'));
                 } });
             userInteraction.next(interactionProps);
             // Start subscribing for external updates to db.cloud.userInteraction, and if so, cancel this request.
@@ -2093,7 +2052,9 @@
             type: 'message-alert',
             title,
             alerts,
-            fields: {}
+            fields: {},
+            submitLabel: 'OK',
+            cancelLabel: null,
         });
     }
     function promptForEmail(userInteraction, title, emailHint) {
@@ -2152,22 +2113,48 @@
             return otp;
         });
     }
+    function confirmLogout(userInteraction, currentUserId, numUnsyncedChanges) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const alerts = [
+                {
+                    type: 'warning',
+                    messageCode: 'LOGOUT_CONFIRMATION',
+                    message: `{numUnsyncedChanges} unsynced changes will get lost!
+                Logout anyway?`,
+                    messageParams: {
+                        currentUserId,
+                        numUnsyncedChanges: numUnsyncedChanges.toString(),
+                    }
+                },
+            ];
+            return yield interactWithUser(userInteraction, {
+                type: 'logout-confirmation',
+                title: 'Confirm Logout',
+                alerts,
+                fields: {},
+                submitLabel: 'Confirm logout',
+                cancelLabel: 'Cancel'
+            })
+                .then(() => true)
+                .catch(() => false);
+        });
+    }
 
     function loadAccessToken(db) {
-        var _a, _b;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const currentUser = yield db.getCurrentUser();
             const { accessToken, accessTokenExpiration, refreshToken, refreshTokenExpiration, claims, } = currentUser;
             if (!accessToken)
-                return;
+                return null;
             const expTime = (_a = accessTokenExpiration === null || accessTokenExpiration === void 0 ? void 0 : accessTokenExpiration.getTime()) !== null && _a !== void 0 ? _a : Infinity;
-            if (expTime > Date.now()) {
-                return accessToken;
+            if (expTime > Date.now() && (((_b = currentUser.license) === null || _b === void 0 ? void 0 : _b.status) || 'ok') === 'ok') {
+                return currentUser;
             }
             if (!refreshToken) {
                 throw new Error(`Refresh token missing`);
             }
-            const refreshExpTime = (_b = refreshTokenExpiration === null || refreshTokenExpiration === void 0 ? void 0 : refreshTokenExpiration.getTime()) !== null && _b !== void 0 ? _b : Infinity;
+            const refreshExpTime = (_c = refreshTokenExpiration === null || refreshTokenExpiration === void 0 ? void 0 : refreshTokenExpiration.getTime()) !== null && _c !== void 0 ? _c : Infinity;
             if (refreshExpTime <= Date.now()) {
                 throw new Error(`Refresh token has expired`);
             }
@@ -2175,8 +2162,10 @@
             yield db.table('$logins').update(claims.sub, {
                 accessToken: refreshedLogin.accessToken,
                 accessTokenExpiration: refreshedLogin.accessTokenExpiration,
+                claims: refreshedLogin.claims,
+                license: refreshedLogin.license,
             });
-            return refreshedLogin.accessToken;
+            return refreshedLogin;
         });
     }
     function authenticate(url, context, fetchToken, userInteraction, hints) {
@@ -2224,10 +2213,24 @@
             if (res.status !== 200)
                 throw new Error(`RefreshToken: Status ${res.status} from ${url}/token`);
             const response = yield res.json();
+            if (response.type === 'error') {
+                throw new TokenErrorResponseError(response);
+            }
             login.accessToken = response.accessToken;
             login.accessTokenExpiration = response.accessTokenExpiration
                 ? new Date(response.accessTokenExpiration)
                 : undefined;
+            login.claims = response.claims;
+            login.license = {
+                type: response.userType,
+                status: response.claims.license || 'ok',
+            };
+            if (response.evalDaysLeft != null) {
+                login.license.evalDaysLeft = response.evalDaysLeft;
+            }
+            if (response.userValidUntil != null) {
+                login.license.validUntil = new Date(response.userValidUntil);
+            }
             return login;
         });
     }
@@ -2259,8 +2262,15 @@
                     public_key: publicKeyPEM,
                     hints,
                 });
+                if (response2.type === 'error') {
+                    throw new TokenErrorResponseError(response2);
+                }
                 if (response2.type !== 'tokens')
                     throw new Error(`Unexpected response type from token endpoint: ${response2.type}`);
+                /*const licenseStatus = response2.claims.license || 'ok';
+                if (licenseStatus !== 'ok') {
+                  throw new InvalidLicenseError(licenseStatus);
+                }*/
                 context.accessToken = response2.accessToken;
                 context.accessTokenExpiration = new Date(response2.accessTokenExpiration);
                 context.refreshToken = response2.refreshToken;
@@ -2271,6 +2281,16 @@
                 context.email = response2.claims.email;
                 context.name = response2.claims.name;
                 context.claims = response2.claims;
+                context.license = {
+                    type: response2.userType,
+                    status: response2.claims.license || 'ok',
+                };
+                if (response2.evalDaysLeft != null) {
+                    context.license.evalDaysLeft = response2.evalDaysLeft;
+                }
+                if (response2.userValidUntil != null) {
+                    context.license.validUntil = new Date(response2.userValidUntil);
+                }
                 if (response2.alerts && response2.alerts.length > 0) {
                     yield interactWithUser(userInteraction, {
                         type: 'message-alert',
@@ -2282,12 +2302,36 @@
                 return context;
             }
             catch (error) {
-                yield alertUser(userInteraction, 'Authentication Failed', {
-                    type: 'error',
-                    messageCode: 'GENERIC_ERROR',
-                    message: `We're having a problem authenticating right now.`,
-                    messageParams: {},
-                }).catch(() => { });
+                if (error instanceof TokenErrorResponseError) {
+                    yield alertUser(userInteraction, error.title, {
+                        type: 'error',
+                        messageCode: error.messageCode,
+                        message: error.message,
+                        messageParams: {},
+                    });
+                    throw error;
+                }
+                let message = `We're having a problem authenticating right now.`;
+                console.error(`Error authenticating`, error);
+                if (error instanceof TypeError) {
+                    const isOffline = typeof navigator !== undefined && !navigator.onLine;
+                    if (isOffline) {
+                        message = `You seem to be offline. Please connect to the internet and try again.`;
+                    }
+                    else if (Dexie__default["default"].debug || (typeof location !== 'undefined' && (location.hostname === 'localhost' || location.hostname === '127.0.0.1'))) {
+                        // The audience is most likely the developer. Suggest to whitelist the localhost origin:
+                        message = `Could not connect to server. Please verify that your origin '${location.origin}' is whitelisted using \`npx dexie-cloud whitelist\``;
+                    }
+                    else {
+                        message = `Could not connect to server. Please verify the connection.`;
+                    }
+                    yield alertUser(userInteraction, 'Authentication Failed', {
+                        type: 'error',
+                        messageCode: 'GENERIC_ERROR',
+                        message,
+                        messageParams: {},
+                    }).catch(() => { });
+                }
                 throw error;
             }
         });
@@ -2334,6 +2378,75 @@
         }
     }
 
+    const UNAUTHORIZED_USER = {
+        userId: "unauthorized",
+        name: "Unauthorized",
+        claims: {
+            sub: "unauthorized",
+        },
+        lastLogin: new Date(0)
+    };
+    try {
+        Object.freeze(UNAUTHORIZED_USER);
+        Object.freeze(UNAUTHORIZED_USER.claims);
+    }
+    catch (_a) { }
+
+    function waitUntil(o, // Works with Dexie's liveQuery observables if we'd need that
+    predicate) {
+        return rxjs.firstValueFrom(rxjs.from(o).pipe(rxjs.filter(predicate)));
+    }
+
+    function logout(db) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const numUnsyncedChanges = yield _logout(db);
+            if (numUnsyncedChanges) {
+                if (yield confirmLogout(db.cloud.userInteraction, db.cloud.currentUserId, numUnsyncedChanges)) {
+                    yield _logout(db, { deleteUnsyncedData: true });
+                }
+                else {
+                    throw new Error(`User cancelled logout due to unsynced changes`);
+                }
+            }
+        });
+    }
+    function _logout(db, { deleteUnsyncedData = false } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Clear the database without emptying configuration options.
+            const [numUnsynced, loggedOut] = yield db.dx.transaction('rw', db.dx.tables, (tx) => __awaiter(this, void 0, void 0, function* () {
+                // @ts-ignore
+                const idbtrans = tx.idbtrans;
+                idbtrans.disableChangeTracking = true;
+                idbtrans.disableAccessControl = true;
+                const mutationTables = tx.storeNames.filter((tableName) => tableName.endsWith('_mutations'));
+                // Count unsynced changes
+                const unsyncCounts = yield Promise.all(mutationTables.map((mutationTable) => tx.table(mutationTable).count()));
+                const sumUnSynced = unsyncCounts.reduce((a, b) => a + b, 0);
+                if (sumUnSynced > 0 && !deleteUnsyncedData) {
+                    // Let caller ask user if they want to delete unsynced data.
+                    return [sumUnSynced, false];
+                }
+                // Either there are no unsynched changes, or caller provided flag deleteUnsynchedData = true.
+                // Clear all tables except $jobs and $syncState (except the persisted sync state which is
+                // also cleared because we're going to rebuild it using a fresh sync).
+                db.$syncState.delete('syncState');
+                for (const table of db.dx.tables) {
+                    if (table.name !== '$jobs' && table.name !== '$syncState') {
+                        table.clear();
+                    }
+                }
+                return [sumUnSynced, true];
+            }));
+            if (loggedOut) {
+                // Wait for currentUser observable to emit UNAUTHORIZED_USER
+                yield waitUntil(db.cloud.currentUser, (user) => user.userId === UNAUTHORIZED_USER.userId);
+                // Then perform an initial sync
+                yield db.cloud.sync({ purpose: 'pull', wait: true });
+            }
+            return numUnsynced;
+        });
+    }
+
     class HttpError extends Error {
         constructor(res, message) {
             super(message || `${res.status} ${res.statusText}`);
@@ -2387,8 +2500,9 @@
                     throw new HttpError(res1, errMsg);
                 }
                 const response = yield res1.json();
-                if (response.type === 'tokens') {
+                if (response.type === 'tokens' || response.type === 'error') {
                     // Demo user request can get a "tokens" response right away
+                    // Error can also be returned right away.
                     return response;
                 }
                 else if (tokenRequest.grant_type === 'otp') {
@@ -2420,12 +2534,6 @@
                     }
                     if (res2.status !== 200) {
                         const errMsg = yield res2.text();
-                        yield alertUser(userInteraction, "OTP Authentication Failed", {
-                            type: 'error',
-                            messageCode: 'GENERIC_ERROR',
-                            message: errMsg,
-                            messageParams: {}
-                        }).catch(() => { });
                         throw new HttpError(res2, errMsg);
                     }
                     const response2 = yield res2.json();
@@ -2438,6 +2546,18 @@
         };
     }
 
+    /** A way to log to console in production without terser stripping out
+     * it from the release bundle.
+     * This should be used very rarely and only in places where it's
+     * absolutely necessary to log something in production.
+     *
+     * @param level
+     * @param args
+     */
+    function prodLog(level, ...args) {
+        globalThis["con" + "sole"][level](...args);
+    }
+
     /** This function changes or sets the current user as requested.
      *
      * Use cases:
@@ -2464,102 +2584,76 @@
                 }));
                 user.isLoggedIn = true;
                 user.lastLogin = new Date();
-                yield user.save();
-                console.debug('Saved new user', user.email);
-            }));
-            yield new Promise((resolve) => {
-                if (db.cloud.currentUserId === user.userId) {
-                    resolve(null);
+                try {
+                    yield user.save();
                 }
-                else {
-                    const subscription = db.cloud.currentUser.subscribe((currentUser) => {
-                        if (currentUser.userId === user.userId) {
-                            subscription.unsubscribe();
-                            resolve(null);
+                catch (e) {
+                    try {
+                        if (e.name === 'DataCloneError') {
+                            // We've seen this buggy behavior in some browsers and in case it happens
+                            // again we really need to collect the details to understand what's going on.
+                            prodLog('debug', `Login context property names:`, Object.keys(user));
+                            prodLog('debug', `Login context property names:`, Object.keys(user));
+                            prodLog('debug', `Login context:`, user);
+                            prodLog('debug', `Login context JSON:`, JSON.stringify(user));
                         }
-                    });
+                    }
+                    catch (_a) { }
+                    throw e;
                 }
-            });
-            // TANKAR!!!!
-            // V: Service workern kommer inte ha tillgång till currentUserObservable om den inte istället härrör från ett liveQuery.
-            // V: Samma med andra windows.
-            // V: Så kanske göra om den till att häröra från liveQuery som läser $logins.orderBy('lastLogin').last().
-            // V: Då bara vara medveten om:
-            //    V: En sån observable börjar hämta data vid första subscribe
-            //    V: Vi har inget "inital value" men kan emulera det till att vara ANONYMOUS_USER
-            //    V: Om requireAuth är true, så borde db.on(ready) hålla databasen stängd för alla utom denna observable.
-            //    V: Om inte så behöver den inte blocka.
-            // Andra tankar:
-            //    * Man kan inte byta användare när man är offline. Skulle gå att flytta realms till undanstuff-tabell vid user-change.
-            //      men troligen inte värt det.
-            //    * Istället: sälj inte inte switch-user funktionalitet utan tala enbart om inloggat vs icke inloggat läge.
-            //    * populate $logins med ANONYMOUS så att en påbörjad inloggning inte räknas, alternativt ha en boolean prop!
-            //      Kanske bäst ha en boolean prop!
-            //    * Alternativ switch-user funktionalitet:
-            //      * DBCore gömmer data från realms man inte har tillgång till.
-            //      * Cursor impl behövs också då.
-            //      * Då blir det snabba user switch.
-            //      * claims-settet som skickas till servern blir summan av alla claims. Då måste servern stödja multipla tokens eller
-            //        att ens token är ett samlad.
+                console.debug('Saved new user', user.email);
+            }));
+            yield waitUntil(db.cloud.currentUser, (currentUser) => currentUser.userId === user.userId);
         });
     }
 
     function login(db, hints) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const currentUser = yield db.getCurrentUser();
-            if (currentUser.isLoggedIn) {
-                if (hints) {
-                    if (hints.email && db.cloud.currentUser.value.email !== hints.email) {
-                        throw new Error(`Must logout before changing user`);
-                    }
-                    if (hints.userId && db.cloud.currentUserId !== hints.userId) {
-                        throw new Error(`Must logout before changing user`);
-                    }
+            const origUserId = currentUser.userId;
+            if (currentUser.isLoggedIn && (!hints || (!hints.email && !hints.userId))) {
+                const licenseStatus = ((_a = currentUser.license) === null || _a === void 0 ? void 0 : _a.status) || 'ok';
+                if (licenseStatus === 'ok' && currentUser.accessToken && (!currentUser.accessTokenExpiration || currentUser.accessTokenExpiration.getTime() > Date.now())) {
+                    // Already authenticated according to given hints. And license is valid.
+                    return false;
                 }
-                // Already authenticated according to given hints.
-                return false;
+                if (currentUser.refreshToken && (!currentUser.refreshTokenExpiration || currentUser.refreshTokenExpiration.getTime() > Date.now())) {
+                    // Refresh the token
+                    yield loadAccessToken(db);
+                    return false;
+                }
+                // No refresh token - must re-authenticate:
             }
             const context = new AuthPersistedContext(db, {
                 claims: {},
                 lastLogin: new Date(0),
             });
             yield authenticate(db.cloud.options.databaseUrl, context, db.cloud.options.fetchTokens || otpFetchTokenCallback(db), db.cloud.userInteraction, hints);
-            try {
-                yield context.save();
-            }
-            catch (e) {
-                try {
-                    if (e.name === 'DataCloneError') {
-                        console.debug(`Login context property names:`, Object.keys(context));
-                        console.debug(`Login context:`, context);
-                        console.debug(`Login context JSON:`, JSON.stringify(context));
-                    }
-                }
-                catch (_a) { }
-                throw e;
-            }
+            if (origUserId !== UNAUTHORIZED_USER.userId && context.userId !== origUserId) {
+                // User was logged in before, but now logged in as another user.
+                yield logout(db);
+            }
+            /*try {
+              await context.save();
+            } catch (e) {
+              try {
+                if (e.name === 'DataCloneError') {
+                  console.debug(`Login context property names:`, Object.keys(context));
+                  console.debug(`Login context:`, context);
+                  console.debug(`Login context JSON:`, JSON.stringify(context));
+                }
+              } catch {}
+              throw e;
+            }*/
             yield setCurrentUser(db, context);
             // Make sure to resync as the new login will be authorized
             // for new realms.
             triggerSync(db, "pull");
-            return true;
+            return context.userId !== origUserId;
         });
     }
 
-    const UNAUTHORIZED_USER = {
-        userId: "unauthorized",
-        name: "Unauthorized",
-        claims: {
-            sub: "unauthorized",
-        },
-        lastLogin: new Date(0)
-    };
-    try {
-        Object.freeze(UNAUTHORIZED_USER);
-        Object.freeze(UNAUTHORIZED_USER.claims);
-    }
-    catch (_a) { }
-
     const swHolder = {};
     const swContainer = typeof self !== 'undefined' && self.document && // self.document is to verify we're not the SW ourself
         typeof navigator !== 'undefined' && navigator.serviceWorker;
@@ -3456,6 +3550,40 @@
                 : change.muts.map((m) => (Object.assign(Object.assign({}, m), { keys: m.keys.slice() }))) });
     }
 
+    // If we get Ratelimit-Limit and Ratelimit-Remaining where Ratelimit-Remaining is below
+    // (Ratelimit-Limit / 2), we should delay the next sync by (Ratelimit-Reset / Ratelimit-Remaining)
+    // seconds (given that there is a Ratelimit-Reset header).
+    let syncRatelimitDelays = new WeakMap();
+    function checkSyncRateLimitDelay(db) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const delatMilliseconds = ((_b = (_a = syncRatelimitDelays.get(db)) === null || _a === void 0 ? void 0 : _a.getTime()) !== null && _b !== void 0 ? _b : 0) - Date.now();
+            if (delatMilliseconds > 0) {
+                console.debug(`Stalling sync request ${delatMilliseconds} ms to spare ratelimits`);
+                yield new Promise(resolve => setTimeout(resolve, delatMilliseconds));
+            }
+        });
+    }
+    function updateSyncRateLimitDelays(db, res) {
+        const limit = res.headers.get('Ratelimit-Limit');
+        const remaining = res.headers.get('Ratelimit-Remaining');
+        const reset = res.headers.get('Ratelimit-Reset');
+        if (limit && remaining && reset) {
+            const limitNum = Number(limit);
+            const remainingNum = Math.max(0, Number(remaining));
+            const willResetInSeconds = Number(reset);
+            if (remainingNum < limitNum / 2) {
+                const delay = Math.ceil(willResetInSeconds / (remainingNum + 1));
+                syncRatelimitDelays.set(db, new Date(Date.now() + delay * 1000));
+                console.debug(`Sync ratelimit delay set to ${delay} seconds`);
+            }
+            else {
+                syncRatelimitDelays.delete(db);
+                console.debug(`Sync ratelimit delay cleared`);
+            }
+        }
+    }
+
     //import {BisonWebStreamReader} from "dreambase-library/dist/typeson-simplified/BisonWebStreamReader";
     function syncWithServer(changes, syncState, baseRevs, db, databaseUrl, schema, clientIdentity, currentUser) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -3464,9 +3592,20 @@
             //
             const headers = {
                 Accept: 'application/json, application/x-bison, application/x-bison-stream',
-                'Content-Type': 'application/tson'
+                'Content-Type': 'application/tson',
             };
-            const accessToken = yield loadAccessToken(db);
+            const updatedUser = yield loadAccessToken(db);
+            /*
+            if (updatedUser?.license && changes.length > 0) {
+              if (updatedUser.license.status === 'expired') {
+                throw new Error(`License has expired`);
+              }
+              if (updatedUser.license.status === 'deactivated') {
+                throw new Error(`License deactivated`);
+              }
+            }
+            */
+            const accessToken = updatedUser === null || updatedUser === void 0 ? void 0 : updatedUser.accessToken;
             if (accessToken) {
                 headers.Authorization = `Bearer ${accessToken}`;
             }
@@ -3475,27 +3614,31 @@
                 dbID: syncState === null || syncState === void 0 ? void 0 : syncState.remoteDbId,
                 clientIdentity,
                 schema: schema || {},
-                lastPull: syncState ? {
-                    serverRevision: syncState.serverRevision,
-                    realms: syncState.realms,
-                    inviteRealms: syncState.inviteRealms
-                } : undefined,
+                lastPull: syncState
+                    ? {
+                        serverRevision: syncState.serverRevision,
+                        realms: syncState.realms,
+                        inviteRealms: syncState.inviteRealms,
+                    }
+                    : undefined,
                 baseRevs,
-                changes: encodeIdsForServer(db.dx.core.schema, currentUser, changes)
+                changes: encodeIdsForServer(db.dx.core.schema, currentUser, changes),
             };
-            console.debug("Sync request", syncRequest);
+            console.debug('Sync request', syncRequest);
             db.syncStateChangedEvent.next({
                 phase: 'pushing',
             });
             const res = yield fetch(`${databaseUrl}/sync`, {
                 method: 'post',
                 headers,
-                body: TSON.stringify(syncRequest)
+                credentials: 'include',
+                body: TSON.stringify(syncRequest),
             });
             //const contentLength = Number(res.headers.get('content-length'));
             db.syncStateChangedEvent.next({
-                phase: 'pulling'
+                phase: 'pulling',
             });
+            updateSyncRateLimitDelays(db, res);
             if (!res.ok) {
                 throw new HttpError(res);
             }
@@ -3697,12 +3840,13 @@
     function sync(db, options, schema, syncOptions) {
         return _sync
             .apply(this, arguments)
-            .then(() => {
+            .then((result) => {
             if (!(syncOptions === null || syncOptions === void 0 ? void 0 : syncOptions.justCheckIfNeeded)) { // && syncOptions?.purpose !== 'push') {
                 db.syncStateChangedEvent.next({
                     phase: 'in-sync',
                 });
             }
+            return result;
         })
             .catch((error) => __awaiter(this, void 0, void 0, function* () {
             if (syncOptions === null || syncOptions === void 0 ? void 0 : syncOptions.justCheckIfNeeded)
@@ -3917,6 +4061,7 @@
             }));
             if (!done) {
                 console.debug('MORE SYNC NEEDED. Go for it again!');
+                yield checkSyncRateLimitDelay(db);
                 return yield _sync(db, options, schema, { isInitialSync, cancelToken });
             }
             console.debug('SYNC DONE', { isInitialSync });
@@ -4053,6 +4198,8 @@
                                 yield db.table('$logins').update(user.userId, {
                                     accessToken: refreshedLogin.accessToken,
                                     accessTokenExpiration: refreshedLogin.accessTokenExpiration,
+                                    claims: refreshedLogin.claims,
+                                    license: refreshedLogin.license,
                                 });
                                 // Updating $logins will trigger emission of db.cloud.currentUser observable, which
                                 // in turn will lead to that connectWebSocket.ts will reconnect the socket with the
@@ -4621,6 +4768,13 @@
 
     const outstandingTransactions = new rxjs.BehaviorSubject(new Set());
 
+    function isEagerSyncDisabled(db) {
+        var _a, _b, _c, _d;
+        return (((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.disableEagerSync) ||
+            ((_c = (_b = db.cloud.currentUser.value) === null || _b === void 0 ? void 0 : _b.license) === null || _c === void 0 ? void 0 : _c.status) !== 'ok' ||
+            !((_d = db.cloud.options) === null || _d === void 0 ? void 0 : _d.databaseUrl));
+    }
+
     /** Tracks all mutations in the same transaction as the mutations -
      * so it is guaranteed that no mutation goes untracked - and if transaction
      * aborts, the mutations won't be tracked.
@@ -4629,7 +4783,7 @@
      * changes to server and cleanup the tracked mutations once the server has
      * ackowledged that it got them.
      */
-    function createMutationTrackingMiddleware({ currentUserObservable, db }) {
+    function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
         return {
             stack: 'dbcore',
             name: 'MutationTrackingMiddleware',
@@ -4640,7 +4794,7 @@
                 try {
                     mutTableMap = new Map(ordinaryTables.map((tbl) => [
                         tbl.name,
-                        core.table(`$${tbl.name}_mutations`)
+                        core.table(`$${tbl.name}_mutations`),
                     ]));
                 }
                 catch (_a) {
@@ -4674,15 +4828,9 @@
                                 outstandingTransactions.next(outstandingTransactions.value);
                             };
                             const txComplete = () => {
-                                var _a;
-                                if (tx.mutationsAdded && ((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.databaseUrl)) {
-                                    if (db.cloud.usingServiceWorker) {
-                                        console.debug('registering sync event');
-                                        registerSyncEvent(db, "push");
-                                    }
-                                    else {
-                                        db.localSyncEvent.next({ purpose: "push" });
-                                    }
+                                if (tx.mutationsAdded &&
+                                    !isEagerSyncDisabled(db)) {
+                                    triggerSync(db, 'push');
                                 }
                                 removeTransaction();
                             };
@@ -4749,7 +4897,7 @@
                                         .query({
                                         query: { range: req.range, index: schema.primaryKey },
                                         trans: req.trans,
-                                        values: false
+                                        values: false,
                                     })
                                         // Do a delete request instead, but keep the criteria info for the server to execute
                                         .then((res) => {
@@ -4757,7 +4905,7 @@
                                             type: 'delete',
                                             keys: res.result,
                                             trans: req.trans,
-                                            criteria: { index: null, range: req.range }
+                                            criteria: { index: null, range: req.range },
                                         });
                                     })
                                     : mutateAndLog(req);
@@ -4765,7 +4913,7 @@
                         function mutateAndLog(req) {
                             const trans = req.trans;
                             trans.mutationsAdded = true;
-                            const { txid, currentUser: { userId } } = trans;
+                            const { txid, currentUser: { userId }, } = trans;
                             const { type } = req;
                             const opNo = ++trans.opCount;
                             return table.mutate(req).then((res) => {
@@ -4786,7 +4934,7 @@
                                         keys,
                                         criteria: req.criteria,
                                         txid,
-                                        userId
+                                        userId,
                                     }
                                     : req.type === 'add'
                                         ? {
@@ -4796,7 +4944,7 @@
                                             keys,
                                             txid,
                                             userId,
-                                            values
+                                            values,
                                         }
                                         : req.criteria && req.changeSpec
                                             ? {
@@ -4808,7 +4956,7 @@
                                                 criteria: req.criteria,
                                                 changeSpec: req.changeSpec,
                                                 txid,
-                                                userId
+                                                userId,
                                             }
                                             : updates
                                                 ? {
@@ -4819,7 +4967,7 @@
                                                     keys: updates.keys,
                                                     changeSpecs: updates.changeSpecs,
                                                     txid,
-                                                    userId
+                                                    userId,
                                                 }
                                                 : {
                                                     type: 'upsert',
@@ -4828,7 +4976,7 @@
                                                     keys,
                                                     values,
                                                     txid,
-                                                    userId
+                                                    userId,
                                                 };
                                 return keys.length > 0 || ('criteria' in req && req.criteria)
                                     ? mutsTable
@@ -4838,7 +4986,7 @@
                             });
                         }
                     } });
-            }
+            },
         };
     }
 
@@ -5197,6 +5345,20 @@
         }
     }
 
+    class InvalidLicenseError extends Error {
+        constructor(license) {
+            super(license === 'expired'
+                ? `License expired`
+                : license === 'deactivated'
+                    ? `User deactivated`
+                    : 'Invalid license');
+            this.name = 'InvalidLicenseError';
+            if (license) {
+                this.license = license;
+            }
+        }
+    }
+
     function sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
@@ -5230,7 +5392,12 @@
         function createObservable() {
             return db.cloud.persistedSyncState.pipe(filter((syncState) => syncState === null || syncState === void 0 ? void 0 : syncState.serverRevision), // Don't connect before there's no initial sync performed.
             take(1), // Don't continue waking up whenever syncState change
-            switchMap((syncState) => db.cloud.currentUser.pipe(map((userLogin) => [userLogin, syncState]))), switchMap(([userLogin, syncState]) => userIsReallyActive.pipe(map((isActive) => [isActive ? userLogin : null, syncState]))), switchMap(([userLogin, syncState]) => {
+            switchMap((syncState) => db.cloud.currentUser.pipe(map((userLogin) => [userLogin, syncState]))), switchMap(([userLogin, syncState]) => {
+                /*if (userLogin.license?.status && userLogin.license.status !== 'ok') {
+                  throw new InvalidLicenseError();
+                }*/
+                return userIsReallyActive.pipe(map((isActive) => [isActive ? userLogin : null, syncState]));
+            }), switchMap(([userLogin, syncState]) => {
                 if ((userLogin === null || userLogin === void 0 ? void 0 : userLogin.isLoggedIn) && !(syncState === null || syncState === void 0 ? void 0 : syncState.realms.includes(userLogin.userId))) {
                     // We're in an in-between state when user is logged in but the user's realms are not yet synced.
                     // Don't make this change reconnect the websocket just yet. Wait till syncState is updated
@@ -5259,14 +5426,20 @@
                         yield db.table('$logins').update(user.userId, {
                             accessToken: refreshedLogin.accessToken,
                             accessTokenExpiration: refreshedLogin.accessTokenExpiration,
+                            claims: refreshedLogin.claims,
+                            license: refreshedLogin.license,
                         });
                     })), switchMap(() => createObservable()));
                 }
                 else {
-                    return rxjs.throwError(error);
+                    return rxjs.throwError(() => error);
                 }
             }), catchError((error) => {
                 db.cloud.webSocketStatus.next("error");
+                if (error instanceof InvalidLicenseError) {
+                    // Don't retry. Just throw and don't try connect again.
+                    return rxjs.throwError(() => error);
+                }
                 return rxjs.from(waitAndReconnectWhenUserDoesSomething(error)).pipe(switchMap(() => createObservable()));
             }));
         }
@@ -5295,97 +5468,12 @@
         });
     }
 
-    const SECONDS = 1000;
-    const MINUTES = 60 * SECONDS;
-
-    const myId = randomString(16);
-
-    const GUARDED_JOB_HEARTBEAT = 1 * SECONDS;
-    const GUARDED_JOB_TIMEOUT = 1 * MINUTES;
-    function performGuardedJob(db, jobName, jobsTableName, job, { awaitRemoteJob } = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Start working.
-            //
-            // Check if someone else is working on this already.
-            //
-            const jobsTable = db.table(jobsTableName);
-            function aquireLock() {
-                return __awaiter(this, void 0, void 0, function* () {
-                    const gotTheLock = yield db.transaction('rw!', jobsTableName, () => __awaiter(this, void 0, void 0, function* () {
-                        const currentWork = yield jobsTable.get(jobName);
-                        if (!currentWork) {
-                            // No one else is working. Let's record that we are.
-                            yield jobsTable.add({
-                                nodeId: myId,
-                                started: new Date(),
-                                heartbeat: new Date()
-                            }, jobName);
-                            return true;
-                        }
-                        else if (currentWork.heartbeat.getTime() <
-                            Date.now() - GUARDED_JOB_TIMEOUT) {
-                            console.warn(`Latest ${jobName} worker seem to have died.\n`, `The dead job started:`, currentWork.started, `\n`, `Last heart beat was:`, currentWork.heartbeat, '\n', `We're now taking over!`);
-                            // Now, take over!
-                            yield jobsTable.put({
-                                nodeId: myId,
-                                started: new Date(),
-                                heartbeat: new Date()
-                            }, jobName);
-                            return true;
-                        }
-                        return false;
-                    }));
-                    if (gotTheLock)
-                        return true;
-                    // Someone else took the job.
-                    if (awaitRemoteJob) {
-                        try {
-                            const jobDoneObservable = rxjs.from(Dexie.liveQuery(() => jobsTable.get(jobName))).pipe(timeout(GUARDED_JOB_TIMEOUT), filter((job) => !job)); // Wait til job is not there anymore.
-                            yield jobDoneObservable.toPromise();
-                            return false;
-                        }
-                        catch (err) {
-                            if (err.name !== 'TimeoutError') {
-                                throw err;
-                            }
-                            // Timeout stopped us! Try aquire the lock now.
-                            // It will likely succeed this time unless
-                            // another client took it.
-                            return yield aquireLock();
-                        }
-                    }
-                    return false;
-                });
-            }
-            if (yield aquireLock()) {
-                // We own the lock entry and can do our job undisturbed.
-                // We're not within a transaction, but these type of locks
-                // spans over transactions.
-                // Start our heart beat during the job.
-                // Use setInterval to make sure we are updating heartbeat even during long-lived fetch calls.
-                const heartbeat = setInterval(() => {
-                    jobsTable.update(jobName, (job) => {
-                        if (job.nodeId === myId) {
-                            job.heartbeat = new Date();
-                        }
-                    });
-                }, GUARDED_JOB_HEARTBEAT);
-                try {
-                    return yield job();
-                }
-                finally {
-                    // Stop heartbeat
-                    clearInterval(heartbeat);
-                    // Remove the persisted job state:
-                    yield db.transaction('rw!', jobsTableName, () => __awaiter(this, void 0, void 0, function* () {
-                        const currentWork = yield jobsTable.get(jobName);
-                        if (currentWork && currentWork.nodeId === myId) {
-                            yield jobsTable.delete(jobName);
-                        }
-                    }));
-                }
-            }
-        });
+    function performGuardedJob(db, jobName, job) {
+        if (typeof navigator === 'undefined' || !navigator.locks) {
+            // No support for guarding jobs. IE11, node.js, etc.
+            return job();
+        }
+        return navigator.locks.request(db.name + '|' + jobName, () => job());
     }
 
     const ongoingSyncs = new WeakMap();
@@ -5439,6 +5527,9 @@
         function _syncIfPossible() {
             return __awaiter(this, void 0, void 0, function* () {
                 try {
+                    // Check if should delay sync due to ratelimit:
+                    yield checkSyncRateLimitDelay(db);
+                    // Check if we need to lock the sync job. Not needed if we are the service worker.
                     if (db.cloud.isServiceWorkerDB) {
                         // We are the dedicated sync SW:
                         yield sync(db, cloudOptions, cloudSchema, options);
@@ -5446,7 +5537,7 @@
                     else if (!db.cloud.usingServiceWorker) {
                         // We use a flow that is better suited for the case when multiple workers want to
                         // do the same thing.
-                        yield performGuardedJob(db, CURRENT_SYNC_WORKER, '$jobs', () => sync(db, cloudOptions, cloudSchema, options));
+                        yield performGuardedJob(db, CURRENT_SYNC_WORKER, () => sync(db, cloudOptions, cloudSchema, options));
                     }
                     else {
                         assert(false);
@@ -5468,19 +5559,29 @@
         }
     }
 
+    const SECONDS = 1000;
+    const MINUTES = 60 * SECONDS;
+
     function LocalSyncWorker(db, cloudOptions, cloudSchema) {
         let localSyncEventSubscription = null;
         //let syncHandler: ((event: Event) => void) | null = null;
         //let periodicSyncHandler: ((event: Event) => void) | null = null;
         let cancelToken = { cancelled: false };
+        let retryHandle = null;
+        let retryPurpose = null; // "pull" is superset of "push"
         function syncAndRetry(purpose, retryNum = 1) {
             // Use setTimeout() to get onto a clean stack and
             // break free from possible active transaction:
             setTimeout(() => {
+                if (retryHandle)
+                    clearTimeout(retryHandle);
+                const combPurpose = retryPurpose === 'pull' ? 'pull' : purpose;
+                retryHandle = null;
+                retryPurpose = null;
                 syncIfPossible(db, cloudOptions, cloudSchema, {
                     cancelToken,
                     retryImmediatelyOnFetchError: true,
-                    purpose,
+                    purpose: combPurpose,
                 }).catch((e) => {
                     console.error('error in syncIfPossible()', e);
                     if (cancelToken.cancelled) {
@@ -5490,7 +5591,13 @@
                         // Mimic service worker sync event: retry 3 times
                         // * first retry after 5 minutes
                         // * second retry 15 minutes later
-                        setTimeout(() => syncAndRetry(purpose, retryNum + 1), [0, 5, 15][retryNum] * MINUTES);
+                        const combinedPurpose = retryPurpose && retryPurpose === 'pull' ? 'pull' : purpose;
+                        const handle = setTimeout(() => syncAndRetry(combinedPurpose, retryNum + 1), [0, 5, 15][retryNum] * MINUTES);
+                        // Cancel the previous retryHandle if it exists to avoid scheduling loads of retries.
+                        if (retryHandle)
+                            clearTimeout(retryHandle);
+                        retryHandle = handle;
+                        retryPurpose = combinedPurpose;
                     }
                 });
             }, 0);
@@ -5557,10 +5664,12 @@
         },
         Alert: {
             error: {
-                color: "red"
+                color: "red",
+                fontWeight: "bold"
             },
             warning: {
-                color: "yellow"
+                color: "#f80",
+                fontWeight: "bold"
             },
             info: {
                 color: "black"
@@ -5601,7 +5710,8 @@
             border: "3px solid #3d3d5d",
             borderRadius: "8px",
             boxShadow: "0 0 80px 10px #666",
-            width: "auto"
+            width: "auto",
+            fontFamily: "sans-serif",
         },
         Input: {
             height: "35px",
@@ -5622,11 +5732,26 @@
 
     var t,r,u,i,o=0,c=[],f=[],e=l$1.__b,a=l$1.__r,v=l$1.diffed,l=l$1.__c,m=l$1.unmount;function d(t,u){l$1.__h&&l$1.__h(r,t,o||u),o=0;var i=r.__H||(r.__H={__:[],__h:[]});return t>=i.__.length&&i.__.push({__V:f}),i.__[t]}function p(n){return o=1,y(z,n)}function y(n,u,i){var o=d(t++,2);if(o.t=n,!o.__c&&(o.__=[i?i(u):z(void 0,u),function(n){var t=o.__N?o.__N[0]:o.__[0],r=o.t(t,n);t!==r&&(o.__N=[r,o.__[1]],o.__c.setState({}));}],o.__c=r,!r.u)){r.u=!0;var c=r.shouldComponentUpdate;r.shouldComponentUpdate=function(n,t,r){if(!o.__c.__H)return !0;var u=o.__c.__H.__.filter(function(n){return n.__c});if(u.every(function(n){return !n.__N}))return !c||c.call(this,n,t,r);var i=!1;return u.forEach(function(n){if(n.__N){var t=n.__[0];n.__=n.__N,n.__N=void 0,t!==n.__[0]&&(i=!0);}}),!!i&&(!c||c.call(this,n,t,r))};}return o.__N||o.__}function s(u,i){var o=d(t++,4);!l$1.__s&&w(o.__H,i)&&(o.__=u,o.i=i,r.__h.push(o));}function _(n){return o=5,F(function(){return {current:n}},[])}function F(n,r){var u=d(t++,7);return w(u.__H,r)?(u.__V=n(),u.i=r,u.__h=n,u.__V):u.__}function b(){for(var t;t=c.shift();)if(t.__P&&t.__H)try{t.__H.__h.forEach(j),t.__H.__h.forEach(k),t.__H.__h=[];}catch(r){t.__H.__h=[],l$1.__e(r,t.__v);}}l$1.__b=function(n){r=null,e&&e(n);},l$1.__r=function(n){a&&a(n),t=0;var i=(r=n.__c).__H;i&&(u===r?(i.__h=[],r.__h=[],i.__.forEach(function(n){n.__N&&(n.__=n.__N),n.__V=f,n.__N=n.i=void 0;})):(i.__h.forEach(j),i.__h.forEach(k),i.__h=[])),u=r;},l$1.diffed=function(t){v&&v(t);var o=t.__c;o&&o.__H&&(o.__H.__h.length&&(1!==c.push(o)&&i===l$1.requestAnimationFrame||((i=l$1.requestAnimationFrame)||function(n){var t,r=function(){clearTimeout(u),g&&cancelAnimationFrame(t),setTimeout(n);},u=setTimeout(r,100);g&&(t=requestAnimationFrame(r));})(b)),o.__H.__.forEach(function(n){n.i&&(n.__H=n.i),n.__V!==f&&(n.__=n.__V),n.i=void 0,n.__V=f;})),u=r=null;},l$1.__c=function(t,r){r.some(function(t){try{t.__h.forEach(j),t.__h=t.__h.filter(function(n){return !n.__||k(n)});}catch(u){r.some(function(n){n.__h&&(n.__h=[]);}),r=[],l$1.__e(u,t.__v);}}),l&&l(t,r);},l$1.unmount=function(t){m&&m(t);var r,u=t.__c;u&&u.__H&&(u.__H.__.forEach(function(n){try{j(n);}catch(n){r=n;}}),r&&l$1.__e(r,u.__v));};var g="function"==typeof requestAnimationFrame;function j(n){var t=r,u=n.__c;"function"==typeof u&&(n.__c=void 0,u()),r=t;}function k(n){var t=r;n.__c=n.__(),r=t;}function w(n,t){return !n||n.length!==t.length||t.some(function(t,r){return t!==n[r]})}function z(n,t){return "function"==typeof t?t(n):t}
 
+    /** Resolve a message template with parameters.
+     *
+     * Example:
+     *  resolveText({
+     *    message: "Hello {name}!",
+     *    messageCode: "HELLO",
+     *    messageParams: {name: "David"}
+     *  }) => "Hello David!"
+     *
+     * @param message Template message with {vars} in it.
+     * @param messageCode Unique code for the message. Can be used for translation.
+     * @param messageParams Parameters to be used in the message.
+     * @returns A final message where parameters have been replaced with values.
+     */
     function resolveText({ message, messageCode, messageParams }) {
-        return message.replace(/\{\w+\}/ig, n => messageParams[n.substr(1, n.length - 2)]);
+        return message.replace(/\{\w+\}/ig, n => messageParams[n.substring(1, n.length - 1)]);
     }
 
-    function LoginDialog({ title, alerts, fields, onCancel, onSubmit, }) {
+    const OTP_LENGTH = 8;
+    function LoginDialog({ title, type, alerts, fields, submitLabel, cancelLabel, onCancel, onSubmit, }) {
         const [params, setParams] = p({});
         const firstFieldRef = _(null);
         s(() => { var _a; return (_a = firstFieldRef.current) === null || _a === void 0 ? void 0 : _a.focus(); }, []);
@@ -5634,21 +5759,34 @@
             h(p$1, null,
                 h("h3", { style: Styles.WindowHeader }, title),
                 alerts.map((alert) => (h("p", { style: Styles.Alert[alert.type] }, resolveText(alert)))),
-                h("form", { onSubmit: ev => {
+                h("form", { onSubmit: (ev) => {
                         ev.preventDefault();
                         onSubmit(params);
-                    } }, Object.entries(fields).map(([fieldName, { type, label, placeholder }], idx) => (h("label", { style: Styles.Label },
+                    } }, Object.entries(fields).map(([fieldName, { type, label, placeholder }], idx) => (h("label", { style: Styles.Label, key: idx },
                     label ? `${label}: ` : '',
-                    h("input", { ref: idx === 0 ? firstFieldRef : undefined, type: type, name: fieldName, autoComplete: "on", style: Styles.Input, autoFocus: true, placeholder: placeholder, value: params[fieldName] || '', onInput: (ev) => { var _a; return setParams(Object.assign(Object.assign({}, params), { [fieldName]: valueTransformer(type, (_a = ev.target) === null || _a === void 0 ? void 0 : _a['value']) })); } })))))),
+                    h("input", { ref: idx === 0 ? firstFieldRef : undefined, type: type, name: fieldName, autoComplete: "on", style: Styles.Input, autoFocus: true, placeholder: placeholder, value: params[fieldName] || '', onInput: (ev) => {
+                            var _a;
+                            const value = valueTransformer(type, (_a = ev.target) === null || _a === void 0 ? void 0 : _a['value']);
+                            let updatedParams = Object.assign(Object.assign({}, params), { [fieldName]: value });
+                            setParams(updatedParams);
+                            if (type === 'otp' && (value === null || value === void 0 ? void 0 : value.trim().length) === OTP_LENGTH) {
+                                // Auto-submit when OTP is filled in.
+                                onSubmit(updatedParams);
+                            }
+                        } })))))),
             h("div", { style: Styles.ButtonsDiv },
-                h("button", { type: "submit", style: Styles.Button, onClick: () => onSubmit(params) }, "Submit"),
-                h("button", { style: Styles.Button, onClick: onCancel }, "Cancel"))));
+                h(p$1, null,
+                    h("button", { type: "submit", style: Styles.Button, onClick: () => onSubmit(params) }, submitLabel),
+                    cancelLabel && (h("button", { style: Styles.Button, onClick: onCancel }, cancelLabel))))));
     }
     function valueTransformer(type, value) {
         switch (type) {
-            case "email": return value.toLowerCase();
-            case "otp": return value.toUpperCase();
-            default: return value;
+            case 'email':
+                return value.toLowerCase();
+            case 'otp':
+                return value.toUpperCase();
+            default:
+                return value;
         }
     }
 
@@ -5702,11 +5840,20 @@
             }
         };
     }
-    // TODO:
-    /*
-        * Gjort klart allt kring user interaction förutom att mounta default-ui på ett element.
-        * Också att kolla först om nån annan subscribar och i så fall inte göra nåt.
-    */
+
+    function associate(factory) {
+        const wm = new WeakMap();
+        return (x) => {
+            let rv = wm.get(x);
+            if (!rv) {
+                rv = factory(x);
+                wm.set(x, rv);
+            }
+            return rv;
+        };
+    }
+
+    const getCurrentUserEmitter = associate((db) => new rxjs.BehaviorSubject(UNAUTHORIZED_USER));
 
     function computeSyncState(db) {
         let _prevStatus = db.cloud.webSocketStatus.value;
@@ -5734,8 +5881,17 @@
         return rxjs.combineLatest([
             lazyWebSocketStatus,
             db.syncStateChangedEvent.pipe(startWith({ phase: 'initial' })),
+            getCurrentUserEmitter(db.dx._novip),
             userIsReallyActive
-        ]).pipe(map(([status, syncState, userIsActive]) => {
+        ]).pipe(map(([status, syncState, user, userIsActive]) => {
+            var _a;
+            if (((_a = user.license) === null || _a === void 0 ? void 0 : _a.status) && user.license.status !== 'ok') {
+                return {
+                    phase: 'offline',
+                    status: 'offline',
+                    license: user.license.status
+                };
+            }
             let { phase, error, progress } = syncState;
             let adjustedStatus = status;
             if (phase === 'error') {
@@ -5768,23 +5924,12 @@
                 error,
                 progress,
                 status: isOnline ? adjustedStatus : 'offline',
+                license: 'ok'
             };
             return retState;
         }));
     }
 
-    function associate(factory) {
-        const wm = new WeakMap();
-        return (x) => {
-            let rv = wm.get(x);
-            if (!rv) {
-                rv = factory(x);
-                wm.set(x, rv);
-            }
-            return rv;
-        };
-    }
-
     function createSharedValueObservable(o, defaultValue) {
         let currentValue = defaultValue;
         let shared = rxjs.from(o).pipe(rxjs.map((x) => (currentValue = x)), rxjs.share({ resetOnRefCountZero: () => rxjs.timer(1000) }));
@@ -5826,8 +5971,6 @@
         })), {});
     });
 
-    const getCurrentUserEmitter = associate((db) => new rxjs.BehaviorSubject(UNAUTHORIZED_USER));
-
     const getInternalAccessControlObservable = associate((db) => {
         return createSharedValueObservable(getCurrentUserEmitter(db._novip).pipe(switchMap((currentUser) => Dexie.liveQuery(() => db.transaction('r', 'realms', 'members', () => Promise.all([
             db.members.where({ userId: currentUser.userId }).toArray(),
@@ -6117,7 +6260,7 @@
         });
         const syncComplete = new rxjs.Subject();
         dexie.cloud = {
-            version: '4.0.1-beta.46',
+            version: '4.0.1-beta.47',
             options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             get currentUserId() {
@@ -6153,11 +6296,24 @@
                 }
                 updateSchemaFromOptions(dexie.cloud.schema, dexie.cloud.options);
             },
+            logout({ force } = {}) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    force
+                        ? yield _logout(DexieCloudDB(dexie), { deleteUnsyncedData: true })
+                        : yield logout(DexieCloudDB(dexie));
+                });
+            },
             sync({ wait, purpose } = { wait: true, purpose: 'push' }) {
+                var _a;
                 return __awaiter(this, void 0, void 0, function* () {
                     if (wait === undefined)
                         wait = true;
                     const db = DexieCloudDB(dexie);
+                    const licenseStatus = ((_a = db.cloud.currentUser.value.license) === null || _a === void 0 ? void 0 : _a.status) || 'ok';
+                    if (licenseStatus !== 'ok') {
+                        // Refresh access token to check for updated license
+                        yield loadAccessToken(db);
+                    }
                     if (purpose === 'pull') {
                         const syncState = db.cloud.persistedSyncState.value;
                         triggerSync(db, purpose);
@@ -6361,7 +6517,9 @@
                         db.syncStateChangedEvent.next({
                             phase: 'not-in-sync',
                         });
-                        triggerSync(db, 'push');
+                        if (!isEagerSyncDisabled(db)) {
+                            triggerSync(db, 'push');
+                        }
                     }), rxjs.fromEvent(self, 'offline').subscribe(() => {
                         console.debug('offline!');
                         db.syncStateChangedEvent.next({
@@ -6378,7 +6536,7 @@
             });
         }
     }
-    dexieCloud.version = '4.0.1-beta.46';
+    dexieCloud.version = '4.0.1-beta.47';
     Dexie__default["default"].Cloud = dexieCloud;
 
     exports["default"] = dexieCloud;