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

package/dist/modern/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
  *
@@ -17,7 +17,7 @@
  */
 
 import Dexie, { cmp, liveQuery } from 'dexie';
-import { Observable as Observable$1, BehaviorSubject, Subject, fromEvent, of, merge, Subscription as Subscription$1, from as from$1, throwError, combineLatest, map as map$1, share, timer as timer$1 } from 'rxjs';
+import { firstValueFrom, from as from$1, filter as filter$1, Observable as Observable$1, BehaviorSubject, Subject, fromEvent, of, merge, Subscription as Subscription$1, throwError, combineLatest, map as map$1, share, timer as timer$1 } from 'rxjs';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -1917,58 +1917,6 @@ function tap(observerOrNext, error, complete) {
             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) {
@@ -2029,6 +1977,7 @@ function registerPeriodicSyncEvent(db) {
 
 function triggerSync(db, purpose) {
     if (db.cloud.usingServiceWorker) {
+        console.debug('registering sync event');
         registerSyncEvent(db, purpose);
     }
     else {
@@ -2060,14 +2009,24 @@ const b64encode = typeof Buffer !== "undefined"
         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.AbortError("User cancelled"));
+                reject(new Dexie.AbortError('User cancelled'));
             } });
         userInteraction.next(interactionProps);
         // Start subscribing for external updates to db.cloud.userInteraction, and if so, cancel this request.
@@ -2086,7 +2045,9 @@ function alertUser(userInteraction, title, ...alerts) {
         type: 'message-alert',
         title,
         alerts,
-        fields: {}
+        fields: {},
+        submitLabel: 'OK',
+        cancelLabel: null,
     });
 }
 function promptForEmail(userInteraction, title, emailHint) {
@@ -2145,22 +2106,48 @@ function promptForOTP(userInteraction, email, alert) {
         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`);
         }
@@ -2168,8 +2155,10 @@ function loadAccessToken(db) {
         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) {
@@ -2217,10 +2206,24 @@ function refreshAccessToken(url, login) {
         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;
     });
 }
@@ -2252,8 +2255,15 @@ function userAuthenticate(context, fetchToken, userInteraction, hints) {
                 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;
@@ -2264,6 +2274,16 @@ function userAuthenticate(context, fetchToken, userInteraction, hints) {
             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',
@@ -2275,12 +2295,36 @@ function userAuthenticate(context, fetchToken, userInteraction, hints) {
             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.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;
         }
     });
@@ -2327,6 +2371,75 @@ class AuthPersistedContext {
     }
 }
 
+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 firstValueFrom(from$1(o).pipe(filter$1(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}`);
@@ -2380,8 +2493,9 @@ function otpFetchTokenCallback(db) {
                 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') {
@@ -2413,12 +2527,6 @@ function otpFetchTokenCallback(db) {
                 }
                 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();
@@ -2431,6 +2539,18 @@ function otpFetchTokenCallback(db) {
     };
 }
 
+/** 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:
@@ -2457,102 +2577,76 @@ function setCurrentUser(db, user) {
             }));
             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;
@@ -3449,6 +3543,40 @@ function cloneChange(change, rewriteValues) {
             : 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* () {
@@ -3457,9 +3585,20 @@ function syncWithServer(changes, syncState, baseRevs, db, databaseUrl, schema, c
         //
         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}`;
         }
@@ -3468,27 +3607,31 @@ function syncWithServer(changes, syncState, baseRevs, db, databaseUrl, schema, c
             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);
         }
@@ -3690,12 +3833,13 @@ const CURRENT_SYNC_WORKER = 'currentSyncWorker';
 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)
@@ -3910,6 +4054,7 @@ function _sync(db, options, schema, { isInitialSync, cancelToken, justCheckIfNee
         }));
         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 });
@@ -4046,6 +4191,8 @@ function MessagesFromServerConsumer(db) {
                             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
@@ -4614,6 +4761,13 @@ function writeLock(fn, prop) {
 
 const outstandingTransactions = new 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.
@@ -4622,7 +4776,7 @@ const outstandingTransactions = new BehaviorSubject(new Set());
  * 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',
@@ -4633,7 +4787,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
             try {
                 mutTableMap = new Map(ordinaryTables.map((tbl) => [
                     tbl.name,
-                    core.table(`$${tbl.name}_mutations`)
+                    core.table(`$${tbl.name}_mutations`),
                 ]));
             }
             catch (_a) {
@@ -4667,15 +4821,9 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                             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();
                         };
@@ -4742,7 +4890,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                     .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) => {
@@ -4750,7 +4898,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                         type: 'delete',
                                         keys: res.result,
                                         trans: req.trans,
-                                        criteria: { index: null, range: req.range }
+                                        criteria: { index: null, range: req.range },
                                     });
                                 })
                                 : mutateAndLog(req);
@@ -4758,7 +4906,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                     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) => {
@@ -4779,7 +4927,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                     keys,
                                     criteria: req.criteria,
                                     txid,
-                                    userId
+                                    userId,
                                 }
                                 : req.type === 'add'
                                     ? {
@@ -4789,7 +4937,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                         keys,
                                         txid,
                                         userId,
-                                        values
+                                        values,
                                     }
                                     : req.criteria && req.changeSpec
                                         ? {
@@ -4801,7 +4949,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                             criteria: req.criteria,
                                             changeSpec: req.changeSpec,
                                             txid,
-                                            userId
+                                            userId,
                                         }
                                         : updates
                                             ? {
@@ -4812,7 +4960,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                                 keys: updates.keys,
                                                 changeSpecs: updates.changeSpecs,
                                                 txid,
-                                                userId
+                                                userId,
                                             }
                                             : {
                                                 type: 'upsert',
@@ -4821,7 +4969,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                                 keys,
                                                 values,
                                                 txid,
-                                                userId
+                                                userId,
                                             };
                             return keys.length > 0 || ('criteria' in req && req.criteria)
                                 ? mutsTable
@@ -4831,7 +4979,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                         });
                     }
                 } });
-        }
+        },
     };
 }
 
@@ -5190,6 +5338,20 @@ class WSConnection extends Subscription$1 {
     }
 }
 
+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));
 }
@@ -5223,7 +5385,12 @@ function connectWebSocket(db) {
     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
@@ -5252,14 +5419,20 @@ function connectWebSocket(db) {
                     yield db.table('$logins').update(user.userId, {
                         accessToken: refreshedLogin.accessToken,
                         accessTokenExpiration: refreshedLogin.accessTokenExpiration,
+                        claims: refreshedLogin.claims,
+                        license: refreshedLogin.license,
                     });
                 })), switchMap(() => createObservable()));
             }
             else {
-                return throwError(error);
+                return 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 throwError(() => error);
+            }
             return from$1(waitAndReconnectWhenUserDoesSomething(error)).pipe(switchMap(() => createObservable()));
         }));
     }
@@ -5288,97 +5461,12 @@ function isSyncNeeded(db) {
     });
 }
 
-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 = from$1(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();
@@ -5432,6 +5520,9 @@ function syncIfPossible(db, cloudOptions, cloudSchema, options) {
     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);
@@ -5439,7 +5530,7 @@ function syncIfPossible(db, cloudOptions, cloudSchema, options) {
                 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);
@@ -5461,19 +5552,29 @@ function syncIfPossible(db, cloudOptions, cloudSchema, options) {
     }
 }
 
+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) {
@@ -5483,7 +5584,13 @@ function LocalSyncWorker(db, cloudOptions, cloudSchema) {
                     // 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);
@@ -5550,10 +5657,12 @@ const Styles = {
     },
     Alert: {
         error: {
-            color: "red"
+            color: "red",
+            fontWeight: "bold"
         },
         warning: {
-            color: "yellow"
+            color: "#f80",
+            fontWeight: "bold"
         },
         info: {
             color: "black"
@@ -5594,7 +5703,8 @@ const Styles = {
         border: "3px solid #3d3d5d",
         borderRadius: "8px",
         boxShadow: "0 0 80px 10px #666",
-        width: "auto"
+        width: "auto",
+        fontFamily: "sans-serif",
     },
     Input: {
         height: "35px",
@@ -5615,11 +5725,26 @@ function Dialog({ children, className }) {
 
 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(); }, []);
@@ -5627,21 +5752,34 @@ function LoginDialog({ title, alerts, fields, onCancel, onSubmit, }) {
         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;
     }
 }
 
@@ -5695,11 +5833,20 @@ function setupDefaultGUI(db) {
         }
     };
 }
-// 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 BehaviorSubject(UNAUTHORIZED_USER));
 
 function computeSyncState(db) {
     let _prevStatus = db.cloud.webSocketStatus.value;
@@ -5727,8 +5874,17 @@ function computeSyncState(db) {
     return 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') {
@@ -5761,23 +5917,12 @@ function computeSyncState(db) {
             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 = from$1(o).pipe(map$1((x) => (currentValue = x)), share({ resetOnRefCountZero: () => timer$1(1000) }));
@@ -5819,8 +5964,6 @@ const getGlobalRolesObservable = associate((db) => {
     })), {});
 });
 
-const getCurrentUserEmitter = associate((db) => new BehaviorSubject(UNAUTHORIZED_USER));
-
 const getInternalAccessControlObservable = associate((db) => {
     return createSharedValueObservable(getCurrentUserEmitter(db._novip).pipe(switchMap((currentUser) => liveQuery(() => db.transaction('r', 'realms', 'members', () => Promise.all([
         db.members.where({ userId: currentUser.userId }).toArray(),
@@ -6110,7 +6253,7 @@ function dexieCloud(dexie) {
     });
     const syncComplete = new Subject();
     dexie.cloud = {
-        version: '4.0.1-beta.46',
+        version: '4.0.1-beta.47',
         options: Object.assign({}, DEFAULT_OPTIONS),
         schema: null,
         get currentUserId() {
@@ -6146,11 +6289,24 @@ function dexieCloud(dexie) {
             }
             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);
@@ -6354,7 +6510,9 @@ function dexieCloud(dexie) {
                     db.syncStateChangedEvent.next({
                         phase: 'not-in-sync',
                     });
-                    triggerSync(db, 'push');
+                    if (!isEagerSyncDisabled(db)) {
+                        triggerSync(db, 'push');
+                    }
                 }), fromEvent(self, 'offline').subscribe(() => {
                     console.debug('offline!');
                     db.syncStateChangedEvent.next({
@@ -6371,7 +6529,7 @@ function dexieCloud(dexie) {
         });
     }
 }
-dexieCloud.version = '4.0.1-beta.46';
+dexieCloud.version = '4.0.1-beta.47';
 Dexie.Cloud = dexieCloud;
 
 export { dexieCloud as default, dexieCloud, getTiedObjectId, getTiedRealmId };