pxt-core 8.6.17 → 8.6.18

package/built/pxt.js

@@ -97891,6 +97891,56 @@ var pxt;
         const PREFERENCES_DEBOUNCE_MAX_MS = 10 * 1000;
         let debouncePreferencesChangedTimeout = 0;
         let debouncePreferencesChangedStarted = 0;
+        //
+        // Local storage of auth token.
+        //
+        // Last known auth token state. This is provided as a convenience for legacy methods that cannot be made async.
+        // Preference hasAuthTokenAsync() over taking a dependency on this cached value.
+        auth.cachedHasAuthToken = false;
+        async function getAuthTokenAsync() {
+            let token;
+            try {
+                token = await pxt.storage.shared.getAsync(AUTH_CONTAINER, CSRF_TOKEN_KEY);
+            }
+            catch (_a) { }
+            auth.cachedHasAuthToken = !!token;
+            return token;
+        }
+        auth.getAuthTokenAsync = getAuthTokenAsync;
+        async function setAuthTokenAsync(token) {
+            auth.cachedHasAuthToken = !!token;
+            return await pxt.storage.shared.setAsync(AUTH_CONTAINER, CSRF_TOKEN_KEY, token);
+        }
+        async function hasAuthTokenAsync() {
+            return !!(await getAuthTokenAsync());
+        }
+        auth.hasAuthTokenAsync = hasAuthTokenAsync;
+        async function delAuthTokenAsync() {
+            auth.cachedHasAuthToken = false;
+            return await pxt.storage.shared.delAsync(AUTH_CONTAINER, CSRF_TOKEN_KEY);
+        }
+        async function getUserStateAsync() {
+            let userState;
+            if (await hasAuthTokenAsync()) {
+                try {
+                    userState = await pxt.storage.shared.getAsync(AUTH_CONTAINER, AUTH_USER_STATE_KEY);
+                }
+                catch (_a) { }
+            }
+            auth.cachedUserState = userState;
+            return userState;
+        }
+        auth.getUserStateAsync = getUserStateAsync;
+        async function setUserStateAsync(state) {
+            if (await hasAuthTokenAsync()) {
+                auth.cachedUserState = Object.assign({}, state);
+                return await pxt.storage.shared.setAsync(AUTH_CONTAINER, AUTH_USER_STATE_KEY, state);
+            }
+        }
+        async function delUserStateAsync() {
+            auth.cachedUserState = undefined;
+            return await pxt.storage.shared.delAsync(AUTH_CONTAINER, AUTH_USER_STATE_KEY);
+        }
         class AuthClient {
             constructor() {
                 this.initialUserPreferences_ = undefined;
@@ -97900,19 +97950,10 @@ var pxt;
                 _client = this;
             }
             async initAsync() {
-                // Load state from local storage
-                try {
-                    this.state$ = await pxt.storage.shared.getAsync(AUTH_CONTAINER, AUTH_USER_STATE_KEY);
-                }
-                catch (_a) { }
-                if (!this.state$) {
-                    this.state$ = {};
-                }
-                this.setUserProfileAsync(this.state$.profile);
-                this.setUserPreferencesAsync(this.state$.preferences);
-            }
-            async authTokenAsync() {
-                return await pxt.storage.shared.getAsync(AUTH_CONTAINER, CSRF_TOKEN_KEY);
+                // Initialize user state from local storage.
+                const state = await getUserStateAsync();
+                this.setUserProfileAsync(state === null || state === void 0 ? void 0 : state.profile);
+                this.setUserPreferencesAsync(state === null || state === void 0 ? void 0 : state.preferences);
             }
             /**
              * Starts the process of authenticating the user against the given identity
@@ -97925,23 +97966,12 @@ var pxt;
              *  flow completes.
              */
             async loginAsync(idp, persistent, callbackState = undefined) {
-                var _a;
                 if (!hasIdentity() || !idpEnabled(idp)) {
                     return;
                 }
                 callbackState = callbackState !== null && callbackState !== void 0 ? callbackState : NilCallbackState;
-                const state = this.getState();
-                // See if we have a valid access token already.
-                if (!state.profile) {
-                    await this.authCheckAsync();
-                }
-                const currIdp = (_a = state.profile) === null || _a === void 0 ? void 0 : _a.idp;
-                // Check if we're already signed into this identity provider.
-                if ((currIdp === null || currIdp === void 0 ? void 0 : currIdp.provider) === idp) {
-                    pxt.debug(`loginAsync: Already signed into ${idp}.`);
-                    return;
-                }
-                this.clearState();
+                // Clear local auth state so we can no longer make authenticated requests.
+                this.clearAuthStateAsync();
                 // Store some continuation state in local storage so we can return to what
                 // the user was doing before signing in.
                 const genId = () => (Math.PI * Math.random()).toString(36).slice(2);
@@ -97967,7 +97997,10 @@ var pxt;
                     window.location.href = apiResult.resp.loginUrl;
                 }
                 else {
-                    await this.onSignInFailed();
+                    try {
+                        await this.onSignInFailed();
+                    }
+                    catch (_a) { }
                 }
             }
             /**
@@ -97977,8 +98010,13 @@ var pxt;
                 if (!hasIdentity()) {
                     return;
                 }
-                this.clearState();
-                return await AuthClient.staticLogoutAsync(continuationHash);
+                // Clear local auth state so we can no longer make authenticated requests.
+                await this.clearAuthStateAsync();
+                await AuthClient.staticLogoutAsync(continuationHash);
+                try {
+                    await this.onSignedOut();
+                }
+                catch (_a) { }
             }
             /**
              * Sign out the user and clear the auth token cookie.
@@ -97988,15 +98026,18 @@ var pxt;
                     return;
                 }
                 pxt.tickEvent('auth.logout');
-                // backend will clear the cookie token and pass back the provider logout endpoint.
-                await AuthClient.staticApiAsync('/api/auth/logout');
-                // Clear csrf token so we can no longer make authenticated requests.
-                await pxt.storage.shared.delAsync(AUTH_CONTAINER, CSRF_TOKEN_KEY);
-                // Update state and UI to reflect logged out state.
-                const hash = continuationHash ? continuationHash.startsWith('#') ? continuationHash : `#${continuationHash}` : "";
-                // Redirect to home screen, or skillmap home screen
+                // Tell backend to clear the http-only auth cookie. Ignore errors here, we want to clear local state even if the backend rejects this request.
+                try {
+                    await AuthClient.staticApiAsync('/api/auth/logout');
+                }
+                catch (_a) { }
+                // Clear local auth state so we can no longer make authenticated requests.
+                await delAuthTokenAsync();
+                await delUserStateAsync();
+                // Redirect to home screen
                 if (pxt.BrowserUtils.hasWindow()) {
-                    window.location.href = `${window.location.origin}${window.location.pathname}${hash}`;
+                    const hash = continuationHash ? continuationHash.startsWith('#') ? continuationHash : `#${continuationHash}` : "";
+                    window.location.href = `${window.location.origin}${window.location.pathname}${window.location.search}${hash}`;
                     location.reload();
                 }
             }
@@ -98006,23 +98047,23 @@ var pxt;
                 if (!await this.loggedInAsync()) {
                     return;
                 }
-                const userId = (_a = this.getState().profile) === null || _a === void 0 ? void 0 : _a.id;
+                const state = await getUserStateAsync();
+                const userId = (_a = state === null || state === void 0 ? void 0 : state.profile) === null || _a === void 0 ? void 0 : _a.id;
                 const res = await this.apiAsync('/api/user', null, 'DELETE');
                 if (res.err) {
-                    await this.onApiError((res.err));
+                    try {
+                        await this.onApiError((res.err));
+                    }
+                    catch (_b) { }
                 }
                 else {
                     try {
-                        // Clear csrf token so we can no longer make authenticated requests.
-                        await pxt.storage.shared.delAsync(AUTH_CONTAINER, CSRF_TOKEN_KEY);
+                        // Clear local auth state so we can no longer make authenticated requests.
+                        await this.clearAuthStateAsync();
                         try {
                             await this.onProfileDeleted(userId);
                         }
-                        catch (_b) {
-                            pxt.tickEvent('auth.profile.cloudToLocalFailed');
-                        }
-                        // Update state and UI to reflect logged out state.
-                        this.clearState();
+                        catch (_c) { }
                     }
                     finally {
                         pxt.tickEvent('auth.profile.deleted');
@@ -98043,12 +98084,12 @@ var pxt;
                 if (!await this.loggedInAsync()) {
                     return undefined;
                 }
-                const state = this.getState();
+                const state = await getUserStateAsync();
                 return Object.assign({}, state.profile);
             }
             async userPreferencesAsync() {
                 //if (!await this.loggedInAsync()) { return undefined; } // allow even when not signed in.
-                const state = this.getState();
+                const state = await getUserStateAsync();
                 return Object.assign({}, state.preferences);
             }
             /**
@@ -98060,12 +98101,12 @@ var pxt;
                 if (!hasIdentity()) {
                     return undefined;
                 }
-                // Fail fast if we don't have csrf token.
-                if (!(await pxt.storage.shared.getAsync(AUTH_CONTAINER, CSRF_TOKEN_KEY))) {
+                if (!(await hasAuthTokenAsync())) {
                     return undefined;
                 }
-                const state = this.getState();
-                if ((_a = state.profile) === null || _a === void 0 ? void 0 : _a.id) {
+                const state = await getUserStateAsync();
+                if ((_a = state === null || state === void 0 ? void 0 : state.profile) === null || _a === void 0 ? void 0 : _a.id) {
+                    // If we already have a user profile, return it.
                     if (!this.initialAuthCheck_) {
                         this.initialAuthCheck_ = Promise.resolve(state.profile);
                     }
@@ -98079,14 +98120,16 @@ var pxt;
                 return this.initialAuthCheck_;
             }
             async loggedInAsync() {
-                await this.authCheckAsync();
-                return this.hasUserId();
+                const profile = await this.authCheckAsync();
+                if (!profile)
+                    return false;
+                return await this.hasUserIdAsync();
             }
             async updateUserProfileAsync(opts) {
                 if (!await this.loggedInAsync()) {
                     return false;
                 }
-                const state = this.getState();
+                const state = await getUserStateAsync();
                 const result = await this.apiAsync('/api/user/profile', {
                     id: state.profile.id,
                     username: opts.username,
@@ -98181,22 +98224,28 @@ var pxt;
                     }
                 }
             }
-            /*protected*/ hasUserId() {
+            async hasUserIdAsync() {
                 var _a;
                 if (!hasIdentity()) {
                     return false;
                 }
-                const state = this.getState();
-                return !!((_a = state.profile) === null || _a === void 0 ? void 0 : _a.id);
+                if (!(await hasAuthTokenAsync())) {
+                    return undefined;
+                }
+                const state = await getUserStateAsync();
+                return !!((_a = state === null || state === void 0 ? void 0 : state.profile) === null || _a === void 0 ? void 0 : _a.id);
             }
             async fetchUserAsync() {
                 var _a;
                 if (!hasIdentity()) {
                     return undefined;
                 }
-                const state = this.getState();
+                if (!(await hasAuthTokenAsync())) {
+                    return undefined;
+                }
+                const state = await getUserStateAsync();
                 // We already have a user, no need to get it again.
-                if ((_a = state.profile) === null || _a === void 0 ? void 0 : _a.id) {
+                if ((_a = state === null || state === void 0 ? void 0 : state.profile) === null || _a === void 0 ? void 0 : _a.id) {
                     return state.profile;
                 }
                 const result = await this.apiAsync('/api/user/profile');
@@ -98208,34 +98257,48 @@ var pxt;
                 return undefined;
             }
             async setUserProfileAsync(profile) {
-                const wasLoggedIn = this.hasUserId();
-                this.transformUserProfile(profile);
-                const isLoggedIn = this.hasUserId();
-                this.onUserProfileChanged();
+                const wasLoggedIn = await this.hasUserIdAsync();
+                await this.transformUserProfileAsync(profile);
+                const isLoggedIn = await this.hasUserIdAsync();
+                try {
+                    await this.onUserProfileChanged();
+                }
+                catch (_a) { }
                 //pxt.data.invalidate(USER_PROFILE);
                 if (isLoggedIn && !wasLoggedIn) {
-                    await this.onSignedIn();
+                    try {
+                        await this.onSignedIn();
+                    }
+                    catch (_b) { }
                     //pxt.data.invalidate(LOGGED_IN);
                 }
                 else if (!isLoggedIn && wasLoggedIn) {
-                    await this.onSignedOut();
+                    try {
+                        await this.onSignedOut();
+                    }
+                    catch (_c) { }
                     //pxt.data.invalidate(LOGGED_IN);
                 }
             }
             async setUserPreferencesAsync(newPref) {
                 var _a;
-                const oldPref = (_a = this.getState().preferences) !== null && _a !== void 0 ? _a : auth.DEFAULT_USER_PREFERENCES();
+                const state = await getUserStateAsync();
+                const oldPref = (_a = state === null || state === void 0 ? void 0 : state.preferences) !== null && _a !== void 0 ? _a : auth.DEFAULT_USER_PREFERENCES();
                 const diff = ts.pxtc.jsonPatch.diff(oldPref, newPref);
                 // update
-                this.transformUserPreferences(Object.assign(Object.assign({}, oldPref), newPref));
-                await this.onUserPreferencesChanged(diff);
+                const finalPref = await this.transformUserPreferencesAsync(Object.assign(Object.assign({}, oldPref), newPref));
+                try {
+                    await this.onUserPreferencesChanged(diff);
+                }
+                catch (_b) { }
+                return finalPref;
             }
             async fetchUserPreferencesAsync() {
                 // Wait for the initial auth
                 if (!await this.loggedInAsync()) {
                     return undefined;
                 }
-                const state = this.getState();
+                const state = await getUserStateAsync();
                 const result = await this.apiAsync('/api/user/preferences');
                 if (result.success) {
                     // Set user profile from returned value
@@ -98243,52 +98306,41 @@ var pxt;
                         // Note the cloud should send partial information back if it is missing
                         // a field. So e.g. if the language has never been set in the cloud, it won't
                         // overwrite the local state.
-                        this.setUserPreferencesAsync(result.resp);
+                        const prefs = this.setUserPreferencesAsync(result.resp);
                         // update our one-time promise for the initial load
-                        return state.preferences;
+                        return prefs;
                     }
                 }
                 return undefined;
             }
             /**
              * Updates user profile state and writes it to local storage.
-             * Direct access to state$ allowed.
              */
-            transformUserProfile(profile) {
-                this.state$ = Object.assign(Object.assign({}, this.state$), { profile: Object.assign({}, profile) });
-                this.saveState();
+            async transformUserProfileAsync(profile) {
+                let state = await getUserStateAsync();
+                state = Object.assign(Object.assign({}, state), { profile: Object.assign({}, profile) });
+                await setUserStateAsync(state);
+                return state.profile;
             }
             /**
              * Updates user preference state and writes it to local storage.
-             * Direct access to state$ allowed.
-             */
-            transformUserPreferences(preferences) {
-                this.state$ = Object.assign(Object.assign({}, this.state$), { preferences: Object.assign({}, preferences) });
-                this.saveState();
-            }
-            /**
-             * Read-only access to current state.
-             * Direct access to state$ allowed.
-             */
-            /*private*/ getState() {
-                return this.state$;
-            }
-            ;
-            /**
-             * Write auth state to local storage.
-             * Direct access to state$ allowed.
              */
-            saveState() {
-                pxt.storage.shared.setAsync(AUTH_CONTAINER, AUTH_USER_STATE_KEY, this.state$).then(() => { });
+            async transformUserPreferencesAsync(preferences) {
+                let state = await getUserStateAsync();
+                state = Object.assign(Object.assign({}, state), { preferences: Object.assign({}, preferences) });
+                await setUserStateAsync(state);
+                return state.preferences;
             }
             /**
-             * Clear all auth state.
-             * Direct access to state$ allowed.
+             * Clear local auth state then call the onStateCleared callback.
              */
-            clearState() {
-                this.state$ = {};
-                pxt.storage.shared.delAsync(AUTH_CONTAINER, AUTH_USER_STATE_KEY)
-                    .then(() => this.onStateCleared());
+            async clearAuthStateAsync() {
+                await delAuthTokenAsync();
+                await delUserStateAsync();
+                try {
+                    await this.onStateCleared();
+                }
+                catch (_a) { }
             }
             /*protected*/ async apiAsync(url, data, method, authToken) {
                 return await AuthClient.staticApiAsync(url, data, method, authToken);
@@ -98296,7 +98348,7 @@ var pxt;
             static async staticApiAsync(url, data, method, authToken) {
                 var _a;
                 const headers = {};
-                authToken = authToken || (await pxt.storage.shared.getAsync(AUTH_CONTAINER, CSRF_TOKEN_KEY));
+                authToken = authToken || (await getAuthTokenAsync());
                 if (authToken) {
                     headers["authorization"] = `mkcd ${authToken}`;
                 }
@@ -98381,14 +98433,14 @@ var pxt;
                 // "Remember me" wasn't selected because this token is not usable
                 // without its cookie-based counterpart. When "Remember me" is false,
                 // the cookie is not persisted.
-                await pxt.storage.shared.setAsync(AUTH_CONTAINER, CSRF_TOKEN_KEY, authToken);
+                await setAuthTokenAsync(authToken);
                 pxt.tickEvent('auth.login.success', { 'provider': loginState.idp });
             } while (false);
             // Clear url parameters and redirect to the callback location.
             const hash = callbackState.hash.startsWith('#') ? callbackState.hash : `#${callbackState.hash}`;
             const params = pxt.Util.stringifyQueryString('', callbackState.params);
             const pathname = loginState.callbackPathname.startsWith('/') ? loginState.callbackPathname : `/${loginState.callbackPathname}`;
-            const redirect = `${pathname}${hash}${params}`;
+            const redirect = `${pathname}${params}${hash}`;
             window.location.href = redirect;
         }
         auth.loginCallbackAsync = loginCallbackAsync;
@@ -98420,9 +98472,9 @@ var pxt;
             return (_d = (_b = (_a = user === null || user === void 0 ? void 0 : user.idp) === null || _a === void 0 ? void 0 : _a.displayName) !== null && _b !== void 0 ? _b : (_c = user === null || user === void 0 ? void 0 : user.idp) === null || _c === void 0 ? void 0 : _c.username) !== null && _d !== void 0 ? _d : EMPTY_USERNAME;
         }
         auth.userName = userName;
-        function identityProviderId() {
-            var _a, _b, _c, _d;
-            return (_d = (_c = (_b = (_a = client()) === null || _a === void 0 ? void 0 : _a.getState()) === null || _b === void 0 ? void 0 : _b.profile) === null || _c === void 0 ? void 0 : _c.idp) === null || _d === void 0 ? void 0 : _d.provider;
+        function identityProviderId(user) {
+            var _a;
+            return (_a = user === null || user === void 0 ? void 0 : user.idp) === null || _a === void 0 ? void 0 : _a.provider;
         }
         auth.identityProviderId = identityProviderId;
         function firstName(user) {
@@ -103525,7 +103577,7 @@ var pxt;
 (function (pxt) {
     var cloud;
     (function (cloud) {
-        const DEV_BACKEND_PROD = "https://www.makecode.com";
+        const DEV_BACKEND_PROD = "https://makecode.com";
         const DEV_BACKEND_STAGING = "https://staging.pxt.io";
         const DEV_BACKEND_LOCALHOST = "http://localhost:8080";
         cloud.DEV_BACKEND = DEV_BACKEND_STAGING;

package/built/pxtlib.d.ts

@@ -84,18 +84,17 @@ declare namespace pxt.auth {
     /**
      * Cloud-synced user state.
      */
-    type State = {
+    type UserState = {
         profile?: UserProfile;
         preferences?: UserPreferences;
     };
     function client(): AuthClient;
+    let cachedHasAuthToken: boolean;
+    function getAuthTokenAsync(): Promise<string>;
+    function hasAuthTokenAsync(): Promise<boolean>;
+    let cachedUserState: Readonly<UserState>;
+    function getUserStateAsync(): Promise<Readonly<UserState>>;
     abstract class AuthClient {
-        /**
-         * In-memory cache of user profile state. This is persisted in local storage.
-         * DO NOT ACCESS DIRECTLY UNLESS YOU KNOW IT IS OK. Functions allowed direct
-         * access are marked as such below.
-         */
-        private state$;
         constructor();
         initAsync(): Promise<void>;
         protected abstract onSignedIn(): Promise<void>;
@@ -106,7 +105,6 @@ declare namespace pxt.auth {
         protected abstract onProfileDeleted(userId: string): Promise<void>;
         protected abstract onApiError(err: any): Promise<void>;
         protected abstract onStateCleared(): Promise<void>;
-        authTokenAsync(): Promise<string>;
         /**
          * Starts the process of authenticating the user against the given identity
          * provider. Upon success the backend will write an http-only session cookie
@@ -147,36 +145,23 @@ declare namespace pxt.auth {
             immediate?: boolean;
             filter?: (op: ts.pxtc.jsonPatch.PatchOperation) => boolean;
         }): Promise<SetPrefResult>;
-        hasUserId(): boolean;
+        private hasUserIdAsync;
         private fetchUserAsync;
         private setUserProfileAsync;
         private setUserPreferencesAsync;
         private fetchUserPreferencesAsync;
         /**
          * Updates user profile state and writes it to local storage.
-         * Direct access to state$ allowed.
          */
-        private transformUserProfile;
+        private transformUserProfileAsync;
         /**
          * Updates user preference state and writes it to local storage.
-         * Direct access to state$ allowed.
-         */
-        protected transformUserPreferences(preferences: UserPreferences): void;
-        /**
-         * Read-only access to current state.
-         * Direct access to state$ allowed.
-         */
-        getState(): Readonly<State>;
-        /**
-         * Write auth state to local storage.
-         * Direct access to state$ allowed.
          */
-        private saveState;
+        protected transformUserPreferencesAsync(preferences: UserPreferences): Promise<UserPreferences>;
         /**
-         * Clear all auth state.
-         * Direct access to state$ allowed.
+         * Clear local auth state then call the onStateCleared callback.
          */
-        private clearState;
+        private clearAuthStateAsync;
         apiAsync<T = any>(url: string, data?: any, method?: string, authToken?: string): Promise<ApiResult<T>>;
         static staticApiAsync<T = any>(url: string, data?: any, method?: string, authToken?: string): Promise<ApiResult<T>>;
     }
@@ -190,7 +175,7 @@ declare namespace pxt.auth {
     function hasIdentity(): boolean;
     function enableAuth(enabled?: boolean): void;
     function userName(user: pxt.auth.UserProfile): string;
-    function identityProviderId(): pxt.IdentityProviderId | undefined;
+    function identityProviderId(user: pxt.auth.UserProfile): pxt.IdentityProviderId | undefined;
     function firstName(user: pxt.auth.UserProfile): string;
     function userInitials(user: pxt.auth.UserProfile): string;
     function generateUserProfilePicDataUrl(profile: pxt.auth.UserProfile): void;
@@ -883,7 +868,7 @@ declare namespace pxt.BrowserUtils {
 }
 declare namespace pxt.cloud {
     export type DevBackendType = "default" | "prod" | "staging" | "localhost";
-    const DEV_BACKEND_PROD = "https://www.makecode.com";
+    const DEV_BACKEND_PROD = "https://makecode.com";
     const DEV_BACKEND_STAGING = "https://staging.pxt.io";
     const DEV_BACKEND_LOCALHOST = "http://localhost:8080";
     type BackendUrls = typeof DEV_BACKEND_PROD | typeof DEV_BACKEND_STAGING | typeof DEV_BACKEND_LOCALHOST;