@jbrowse/plugin-authentication 4.3.0 → 5.0.0-beta.10

package/esm/GoogleDriveOAuthModel/model.js

@@ -1,35 +1,59 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { ConfigurationReference } from '@jbrowse/core/configuration';
 import { types } from '@jbrowse/mobx-state-tree';
-import { GoogleDriveFile } from "./GoogleDriveFilehandle.js";
-import GoogleDriveIcon from "./GoogleDriveIcon.js";
-import { getDescriptiveErrorMessage } from "./util.js";
-import { configSchema as OAuthConfigSchema } from "../OAuthModel/index.js";
-import baseModel from "../OAuthModel/model.js";
+import { configSchema as OAuthConfigSchema } from '../OAuthModel/index.js';
+import baseModel from '../OAuthModel/model.js';
+import { GoogleDriveFile } from './GoogleDriveFilehandle.js';
+import GoogleDriveIcon from './GoogleDriveIcon.js';
+import { getDescriptiveErrorMessage } from './util.js';
 function getUri(str) {
-    const urlId = /[-\w]{25,}/.exec(str);
-    return `https://www.googleapis.com/drive/v3/files/${urlId}`;
+    const urlId = /\/d\/([-\w]{25,})/.exec(str);
+    if (!urlId) {
+        throw new Error(`Could not extract Google Drive file ID from URL: ${str}`);
+    }
+    return `https://www.googleapis.com/drive/v3/files/${urlId[1]}`;
 }
+/**
+ * #stateModel GoogleDriveOAuthInternetAccount
+ */
 export default function stateModelFactory(configSchema) {
     return baseModel(OAuthConfigSchema)
         .named('GoogleDriveOAuthInternetAccount')
         .props({
+        /**
+         * #property
+         */
         type: types.literal('GoogleDriveOAuthInternetAccount'),
+        /**
+         * #property
+         */
         configuration: ConfigurationReference(configSchema),
     })
         .views(() => ({
+        /**
+         * #getter
+         * The FileSelector icon for Google drive
+         */
         get toggleContents() {
             return _jsx(GoogleDriveIcon, {});
         },
+        /**
+         * #getter
+         */
         get selectorLabel() {
             return 'Enter Google Drive share link';
         },
     }))
         .actions(self => ({
+        /**
+         * #method
+         */
         getFetcher(location) {
             return async (input, init) => {
                 const driveUrl = new URL(getUri(String(input)));
                 const searchParams = new URLSearchParams();
+                // metadataOnly: private flag used by GoogleDriveFile constructor to
+                // pre-fetch just the file size for stat() without downloading content
                 if (init?.metadataOnly) {
                     searchParams.append('fields', 'size');
                 }
@@ -37,30 +61,29 @@ export default function stateModelFactory(configSchema) {
                     searchParams.append('alt', 'media');
                 }
                 driveUrl.search = searchParams.toString();
-                const authToken = await self.getToken(location);
-                const response = await fetch(driveUrl, self.addAuthHeaderToInit({ ...init, method: 'GET', credentials: 'same-origin' }, authToken));
+                const response = await self.fetchWithToken(location, authToken => fetch(driveUrl, self.addAuthHeaderToInit({ ...init, method: 'GET', credentials: 'same-origin' }, authToken)));
                 if (!response.ok) {
                     throw new Error(await getDescriptiveErrorMessage(response));
                 }
                 return response;
             };
         },
+        /**
+         * #action
+         */
+        async validateToken(token, location) {
+            const uri = getUri(location.uri);
+            return self.validateTokenWithProbe(token, authToken => fetch(uri, { headers: { Authorization: `Bearer ${authToken}` } }), getDescriptiveErrorMessage);
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #method
+         */
         openLocation(location) {
             return new GoogleDriveFile(location.uri, {
-                fetch: this.getFetcher(location),
-            });
-        },
-        async validateToken(token, location) {
-            const response = await fetch(getUri(location.uri), {
-                headers: {
-                    Authorization: `Bearer ${token}`,
-                    'Content-Type': 'application/x-www-form-urlencoded',
-                },
+                fetch: self.getFetcher(location),
             });
-            if (!response.ok) {
-                throw new Error(await getDescriptiveErrorMessage(response, 'Token could not be validated'));
-            }
-            return token;
         },
     }));
 }

package/esm/GoogleDriveOAuthModel/util.d.ts

@@ -1 +1 @@
-export declare function getDescriptiveErrorMessage(response: Response, reason?: string): Promise<string>;
+export declare const getDescriptiveErrorMessage: (response: Response, reason?: string) => Promise<string>;

package/esm/GoogleDriveOAuthModel/util.js

@@ -1,11 +1,2 @@
-import { getResponseError } from "../util.js";
-export async function getDescriptiveErrorMessage(response, reason) {
-    let errorMessage = '';
-    try {
-        const err = JSON.parse(await response.text());
-        errorMessage = err.error.message;
-    }
-    catch (error) {
-    }
-    return getResponseError({ response, reason, statusText: errorMessage });
-}
+import { descriptiveErrorMessage } from '../util.js';
+export const getDescriptiveErrorMessage = descriptiveErrorMessage(err => err.error.message);

package/esm/HTTPBasicModel/HTTPBasicLoginForm.d.ts

@@ -1,4 +1,4 @@
 export declare function HTTPBasicLoginForm({ internetAccountId, handleClose, }: {
     internetAccountId: string;
     handleClose: (arg?: string) => void;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

package/esm/HTTPBasicModel/HTTPBasicLoginForm.js

@@ -1,29 +1,24 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from 'react';
-import { Dialog } from '@jbrowse/core/ui';
-import { Button, DialogActions, DialogContent, TextField } from '@mui/material';
+import { SubmitDialog } from '@jbrowse/core/ui';
+import { TextField } from '@mui/material';
 export function HTTPBasicLoginForm({ internetAccountId, handleClose, }) {
     const [username, setUsername] = useState('');
     const [password, setPassword] = useState('');
-    return (_jsx(Dialog, { open: true, maxWidth: "xl", "data-testid": "login-httpbasic", title: `Log in for ${internetAccountId}`, onClose: () => {
+    return (_jsx(SubmitDialog, { open: true, maxWidth: "xl", "data-testid": "login-httpbasic", title: `Log in for ${internetAccountId}`, 
+        // an incomplete submit used to close as if cancelled, which the account
+        // reports as "User cancelled entry" — a failed login the user never made
+        submitDisabled: !username || !password, onCancel: () => {
             handleClose();
-        }, children: _jsxs("form", { onSubmit: event => {
-                if (username && password) {
-                    handleClose(btoa(`${username}:${password}`));
-                }
-                else {
-                    handleClose();
-                }
-                event.preventDefault();
-            }, children: [_jsxs(DialogContent, { style: { display: 'flex', flexDirection: 'column' }, children: [_jsx(TextField, { required: true, label: "Username", variant: "outlined", onChange: event => {
-                                setUsername(event.target.value);
-                            }, margin: "dense", slotProps: {
-                                htmlInput: { 'data-testid': 'login-httpbasic-username' },
-                            } }), _jsx(TextField, { required: true, label: "Password", type: "password", autoComplete: "current-password", variant: "outlined", onChange: event => {
-                                setPassword(event.target.value);
-                            }, margin: "dense", slotProps: {
-                                htmlInput: { 'data-testid': 'login-httpbasic-password' },
-                            } })] }), _jsxs(DialogActions, { children: [_jsx(Button, { variant: "contained", color: "primary", type: "submit", children: "Submit" }), _jsx(Button, { variant: "contained", color: "secondary", type: "submit", onClick: () => {
-                                handleClose();
-                            }, children: "Cancel" })] })] }) }));
+        }, onSubmit: () => {
+            handleClose(btoa(`${username}:${password}`));
+        }, children: _jsxs("div", { style: { display: 'flex', flexDirection: 'column' }, children: [_jsx(TextField, { required: true, label: "Username", variant: "outlined", onChange: event => {
+                        setUsername(event.target.value);
+                    }, margin: "dense", slotProps: {
+                        htmlInput: { 'data-testid': 'login-httpbasic-username' },
+                    } }), _jsx(TextField, { required: true, label: "Password", type: "password", autoComplete: "current-password", variant: "outlined", onChange: event => {
+                        setPassword(event.target.value);
+                    }, margin: "dense", slotProps: {
+                        htmlInput: { 'data-testid': 'login-httpbasic-password' },
+                    } })] }) }));
 }

package/esm/HTTPBasicModel/configSchema.d.ts

@@ -1,42 +1,99 @@
 import type { Instance } from '@jbrowse/mobx-state-tree';
+/**
+ * #config HTTPBasicInternetAccount
+ *
+ * #example
+ * An entry in the config's `internetAccounts`. JBrowse prompts for the username
+ * and password the first time a file under one of `domains` is opened, and
+ * sends them as an `Authorization: Basic …` header from then on.
+ * ```js
+ * {
+ *   type: 'HTTPBasicInternetAccount',
+ *   internetAccountId: 'myLabServer',
+ *   name: 'My lab server',
+ *   description: 'Sequencing data behind the lab htaccess',
+ *   domains: ['data.mylab.org'],
+ * }
+ * ```
+ */
 declare const HTTPBasicConfigSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+    authHeader: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    description: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    domains: {
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
+    };
+    internetAccountId: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    name: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
     tokenType: {
-        description: string;
-        type: string;
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    type: {
+        type: "string";
+    } & {
         defaultValue: string;
     };
     validateWithHEAD: {
-        description: string;
-        type: string;
+        type: "boolean";
+    } & {
         defaultValue: boolean;
     };
 }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    name: {
-        description: string;
-        type: string;
+    readonly name: {
+        type: "string";
+    } & {
         defaultValue: string;
     };
-    description: {
-        description: string;
-        type: string;
+    readonly description: {
+        type: "string";
+    } & {
         defaultValue: string;
     };
-    authHeader: {
-        description: string;
-        type: string;
+    readonly authHeader: {
+        type: "string";
+    } & {
         defaultValue: string;
     };
-    tokenType: {
-        description: string;
-        type: string;
+    readonly tokenType: {
+        type: "string";
+    } & {
         defaultValue: string;
     };
-    domains: {
-        description: string;
-        type: string;
-        defaultValue: never[];
+    readonly domains: {
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
+    };
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    internetAccountId: {
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "internetAccountId">>, undefined>>;
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "internetAccountId", true, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>, undefined, true, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
 export type HTTPBasicInternetAccountConfigModel = typeof HTTPBasicConfigSchema;
 export type HTTPBasicInternetAccountConfig = Instance<HTTPBasicInternetAccountConfigModel>;
 export default HTTPBasicConfigSchema;

package/esm/HTTPBasicModel/configSchema.js

@@ -1,18 +1,43 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
 import { BaseInternetAccountConfig } from '@jbrowse/core/pluggableElementTypes/models';
-function x() { }
+/**
+ * #config HTTPBasicInternetAccount
+ *
+ * #example
+ * An entry in the config's `internetAccounts`. JBrowse prompts for the username
+ * and password the first time a file under one of `domains` is opened, and
+ * sends them as an `Authorization: Basic …` header from then on.
+ * ```js
+ * {
+ *   type: 'HTTPBasicInternetAccount',
+ *   internetAccountId: 'myLabServer',
+ *   name: 'My lab server',
+ *   description: 'Sequencing data behind the lab htaccess',
+ *   domains: ['data.mylab.org'],
+ * }
+ * ```
+ */
 const HTTPBasicConfigSchema = ConfigurationSchema('HTTPBasicInternetAccount', {
+    /**
+     * #slot
+     */
     tokenType: {
         description: 'a custom name for a token to include in the header',
         type: 'string',
         defaultValue: 'Basic',
     },
+    /**
+     * #slot
+     */
     validateWithHEAD: {
         description: 'validate the token with a HEAD request before using it',
         type: 'boolean',
         defaultValue: true,
     },
 }, {
+    /**
+     * #baseConfiguration
+     */
     baseConfiguration: BaseInternetAccountConfig,
     explicitlyTyped: true,
 });

package/esm/HTTPBasicModel/index.js

@@ -1,2 +1,2 @@
-export { default as configSchema } from "./configSchema.js";
-export { default as modelFactory } from "./model.js";
+export { default as configSchema } from './configSchema.js';
+export { default as modelFactory } from './model.js';

package/esm/HTTPBasicModel/model.d.ts

@@ -1,76 +1,55 @@
 import type { HTTPBasicInternetAccountConfigModel } from './configSchema.ts';
-import type { UriLocation } from '@jbrowse/core/util/types';
 import type { Instance } from '@jbrowse/mobx-state-tree';
-declare const stateModelFactory: (configSchema: HTTPBasicInternetAccountConfigModel) => import("@jbrowse/mobx-state-tree").IModelType<{
+/**
+ * #stateModel HTTPBasicInternetAccount
+ * Internet account that authenticates requests with an HTTP Basic
+ * username/password the user enters through a dialog, optionally validated with
+ * a HEAD request. See [TokenEntryInternetAccount](../tokenentryinternetaccount)
+ * for the shared behavior.
+ */
+declare const stateModelFactory: (configSchema: HTTPBasicInternetAccountConfigModel) => import("@jbrowse/mobx-state-tree").IModelType<Omit<{
     id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
     type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
-    configuration: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-        name: {
-            description: string;
-            type: string;
+    configuration: import("@jbrowse/core/configuration/configurationSchema").IConfigurationReference<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly name: {
+            type: "string";
+        } & {
             defaultValue: string;
         };
-        description: {
-            description: string;
-            type: string;
+        readonly description: {
+            type: "string";
+        } & {
             defaultValue: string;
         };
-        authHeader: {
-            description: string;
-            type: string;
+        readonly authHeader: {
+            type: "string";
+        } & {
             defaultValue: string;
         };
-        tokenType: {
-            description: string;
-            type: string;
+        readonly tokenType: {
+            type: "string";
+        } & {
             defaultValue: string;
         };
-        domains: {
-            description: string;
-            type: string;
-            defaultValue: never[];
+        readonly domains: {
+            type: "stringArray";
+        } & {
+            defaultValue: unknown;
         };
-    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "internetAccountId">>;
-} & {
-    type: import("@jbrowse/mobx-state-tree").ISimpleType<"HTTPBasicInternetAccount">;
-    configuration: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-        tokenType: {
-            description: string;
-            type: string;
-            defaultValue: string;
-        };
-        validateWithHEAD: {
-            description: string;
-            type: string;
-            defaultValue: boolean;
-        };
-    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-        name: {
-            description: string;
-            type: string;
-            defaultValue: string;
-        };
-        description: {
-            description: string;
-            type: string;
-            defaultValue: string;
-        };
-        authHeader: {
-            description: string;
-            type: string;
+        type: {
+            type: "string";
+        } & {
             defaultValue: string;
         };
-        tokenType: {
-            description: string;
-            type: string;
+        internetAccountId: {
+            type: "string";
+        } & {
             defaultValue: string;
         };
-        domains: {
-            description: string;
-            type: string;
-            defaultValue: never[];
-        };
-    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "internetAccountId">>, undefined>>;
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "internetAccountId", true, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>>;
+}, "configuration" | "type"> & {
+    type: import("@jbrowse/mobx-state-tree").ILiteralType<"HTTPBasicInternetAccount">;
+    configuration: import("@jbrowse/core/configuration/configurationSchema").IConfigurationReference<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>;
 }, {
     readonly name: string;
     readonly description: string;
@@ -79,22 +58,21 @@ declare const stateModelFactory: (configSchema: HTTPBasicInternetAccountConfigMo
     readonly tokenType: string;
     readonly domains: string[];
     readonly toggleContents: React.ReactNode;
-    readonly SelectorComponent: import("@jbrowse/core/util").AnyReactComponentType | undefined;
     readonly selectorLabel: string | undefined;
+    readonly showInFileSelector: boolean;
 } & {
-    handlesLocation(location: UriLocation): boolean;
+    handlesLocation(location: import("@jbrowse/core/util").UriLocation): boolean;
     readonly tokenKey: string;
 } & {
     getTokenFromUser(_resolve: (token: string) => void, _reject: (error: Error) => void): void;
     storeToken(token: string): void;
-    removeToken(): void;
-    retrieveToken(): string | null;
-    validateToken(token: string, _loc: UriLocation): Promise<string>;
+    retrieveToken(): string | undefined;
+    validateToken(token: string, _loc: import("@jbrowse/core/util").UriLocation): Promise<string>;
 } & {
-    getToken(location?: UriLocation): Promise<string>;
+    removeToken(): void;
+    getToken(location?: import("@jbrowse/core/util").UriLocation): Promise<string>;
 } & {
     addAuthHeaderToInit(init?: RequestInit, token?: string): {
-        headers: Headers;
         body?: BodyInit | null;
         cache?: RequestCache;
         credentials?: RequestCredentials;
@@ -108,23 +86,34 @@ declare const stateModelFactory: (configSchema: HTTPBasicInternetAccountConfigMo
         referrerPolicy?: ReferrerPolicy;
         signal?: AbortSignal | null;
         window?: null;
+        headers: Headers;
     };
-    getPreAuthorizationInformation(location: UriLocation): Promise<{
+    fetchWithToken(loc: import("@jbrowse/core/util").UriLocation | undefined, run: (token: string) => Promise<Response>): Promise<Response>;
+    getPreAuthorizationInformation(location: import("@jbrowse/core/util").UriLocation): Promise<{
         internetAccountType: string;
         authInfo: {
             token: string;
-            configuration: any;
+            configuration: import("@jbrowse/mobx-state-tree").ModelSnapshotType<Record<string, any>>;
         };
     }>;
 } & {
-    getFetcher(loc?: UriLocation): (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+    getFetcher(loc?: import("@jbrowse/core/util").UriLocation): (input: RequestInfo, init?: RequestInit) => Promise<Response>;
 } & {
-    openLocation(location: UriLocation): import("@jbrowse/core/util/io").RemoteFileWithRangeCache;
+    openLocation(location: import("@jbrowse/core/util").UriLocation): import("@gmod/range-cache-filehandle").RemoteFileWithRangeCache;
 } & {
     readonly validateWithHEAD: boolean;
 } & {
     getTokenFromUser(resolve: (token: string) => void, reject: (error: Error) => void): void;
-    validateToken(token: string, location: UriLocation): Promise<string>;
+    validateToken(token: string, location: import("@jbrowse/core/util").UriLocation): Promise<string>;
+} & {
+    /**
+     * #getter
+     * There is nothing to pick: an HTTP Basic account matches by domain and
+     * prompts on its own. RpcManager also mints one of these per origin on a
+     * 401, so offering them would fill the picker with a toggle per server the
+     * session happened to touch.
+     */
+    readonly showInFileSelector: boolean;
 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
 export default stateModelFactory;
 export type HTTPBasicStateModel = ReturnType<typeof stateModelFactory>;

package/esm/HTTPBasicModel/model.js

@@ -1,52 +1,22 @@
-import { ConfigurationReference, getConf } from '@jbrowse/core/configuration';
-import { InternetAccount } from '@jbrowse/core/pluggableElementTypes/models';
-import { getRoot, types } from '@jbrowse/mobx-state-tree';
-import { HTTPBasicLoginForm } from "./HTTPBasicLoginForm.js";
-import { getResponseError } from "../util.js";
-const stateModelFactory = (configSchema) => {
-    return InternetAccount.named('HTTPBasicInternetAccount')
-        .props({
-        type: types.literal('HTTPBasicInternetAccount'),
-        configuration: ConfigurationReference(configSchema),
-    })
-        .views(self => ({
-        get validateWithHEAD() {
-            return getConf(self, 'validateWithHEAD');
-        },
-    }))
-        .actions(self => ({
-        getTokenFromUser(resolve, reject) {
-            const { session } = getRoot(self);
-            session.queueDialog((doneCallback) => [
-                HTTPBasicLoginForm,
-                {
-                    internetAccountId: self.internetAccountId,
-                    handleClose: (token) => {
-                        if (token) {
-                            resolve(token);
-                        }
-                        else {
-                            reject(new Error('User cancelled entry'));
-                        }
-                        doneCallback();
-                    },
-                },
-            ]);
-        },
-        async validateToken(token, location) {
-            if (!self.validateWithHEAD) {
-                return token;
-            }
-            const newInit = self.addAuthHeaderToInit({ method: 'HEAD' }, token);
-            const response = await fetch(location.uri, newInit);
-            if (!response.ok) {
-                throw new Error(await getResponseError({
-                    response,
-                    reason: 'Error validating token',
-                }));
-            }
-            return token;
-        },
-    }));
-};
+import { HTTPBasicLoginForm } from '../lazyLoginForms.js';
+import { tokenEntryModelFactory } from '../tokenEntryModelFactory.js';
+/**
+ * #stateModel HTTPBasicInternetAccount
+ * Internet account that authenticates requests with an HTTP Basic
+ * username/password the user enters through a dialog, optionally validated with
+ * a HEAD request. See [TokenEntryInternetAccount](../tokenentryinternetaccount)
+ * for the shared behavior.
+ */
+const stateModelFactory = (configSchema) => tokenEntryModelFactory('HTTPBasicInternetAccount', 'HTTPBasicInternetAccount', configSchema, HTTPBasicLoginForm).views(() => ({
+    /**
+     * #getter
+     * There is nothing to pick: an HTTP Basic account matches by domain and
+     * prompts on its own. RpcManager also mints one of these per origin on a
+     * 401, so offering them would fill the picker with a toggle per server the
+     * session happened to touch.
+     */
+    get showInFileSelector() {
+        return false;
+    },
+}));
 export default stateModelFactory;

package/esm/OAuthModel/OAuthLoginPrompt.d.ts

@@ -0,0 +1,4 @@
+export declare function OAuthLoginPrompt({ internetAccountId, handleClose, }: {
+    internetAccountId: string;
+    handleClose: (proceed: boolean) => void;
+}): import("react").JSX.Element;

package/esm/OAuthModel/OAuthLoginPrompt.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Dialog } from '@jbrowse/core/ui';
+import { Button, DialogActions, DialogContent, Typography } from '@mui/material';
+export function OAuthLoginPrompt({ internetAccountId, handleClose, }) {
+    return (_jsxs(Dialog, { open: true, maxWidth: "xs", "data-testid": "oauth-login-prompt", title: `Log in to ${internetAccountId}`, onClose: () => {
+            handleClose(false);
+        }, children: [_jsx(DialogContent, { children: _jsxs(Typography, { children: ["This session has a track that needs you to log in to", ' ', internetAccountId, ". Browsers only allow the login window to open from a click, so it could not be opened on your behalf."] }) }), _jsxs(DialogActions, { children: [_jsx(Button, { color: "secondary", variant: "contained", onClick: () => {
+                            handleClose(false);
+                        }, children: "Cancel" }), _jsx(Button, { color: "primary", variant: "contained", onClick: () => {
+                            handleClose(true);
+                        }, children: "Log in" })] })] }));
+}