@jlab-enhanced/favorites 3.1.0 → 3.2.1

package/README.md

@@ -1,6 +1,6 @@
 # jupyterlab-favorites
 
-[![Extension status](https://img.shields.io/badge/status-ready-success "ready to be used")](https://jupyterlab-contrib.github.io/)
+[![Extension status](https://img.shields.io/badge/status-ready-success 'ready to be used')](https://jupyterlab-contrib.github.io/)
 [![Github Actions Status](https://github.com/jupyterlab-contrib/jupyterlab-favorites/workflows/Build/badge.svg)](https://github.com/jupyterlab-contrib/jupyterlab-favorites/actions?query=workflow%3ABuild)
 [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/jupyterlab-contrib/jupyterlab-favorites/master?urlpath=lab)
 [![npm](https://img.shields.io/npm/v/@jlab-enhanced/favorites)](https://www.npmjs.com/package/@jlab-enhanced/favorites)
@@ -11,114 +11,80 @@ Add the ability to save favorite folders to JupyterLab for quicker browsing.
 
 ![JupyterLab Favorites extension demonstration](https://raw.githubusercontent.com/jupyterlab-contrib/jupyterlab-favorites/master/jupyterlab-favorites.gif)
 
-## Installation
+## Requirements
 
-### Prerequisites
+- JupyterLab >= 4.0.0 or Notebook >= 7.0.0
 
-- JupyterLab 3.x
+> For JupyterLab 3, you can install jupyterlab-favorites 3.1.x using pip for example:
 
-### Install from pypi
-
-```
-python -m pip install jupyterlab-favorites
-```
-
-### Install from github
-
-```
-python -m pip install "git+https://github.com/jupyterlab-contrib/jupyterlab-favorites@v3.0.0#egg=jupyterlab_favorites"
+```sh
+pip install "jupyterlab-favorites~=3.1.1"
 ```
 
-### Install locally from a git checkout
+## Install
 
-```
-git clone https://github.com/jupyterlab-contrib/jupyterlab-favorites.git
-cd jupyterlab-favorites
-pip install .
-```
-
-## Development
-
-### Prerequisites
-
-- An active `conda` environment with JupyterLab 3.x installed
-
-### Install locally from a git checkout
+To install the extension, execute:
 
 ```bash
-git clone https://github.com/jupyterlab-contrib/jupyterlab-favorites.git
-cd jupyterlab-favorites
-pip install -ve .
+pip install jupyterlab_favorites
 ```
 
-This copies the frontend code for the extension into JupyterLab.
+## Uninstall
 
-To keep the source code synced with JupyterLab, you can run the following:
+To remove the extension, execute:
 
 ```bash
-jupyter labextension develop --overwrite .
+pip uninstall jupyterlab_favorites
 ```
 
-To rebuild the extension manually after each change::
+## Contributing
 
-```bash
-jlpm run build
-```
+### Development install
 
-To automatically rebuild after each change, run in a separate terminal:
+Note: You will need NodeJS to build the extension package.
 
-```bash
-jlpm run watch
-```
-
-## Older JupyterLab versions
-
-### JupyterLab v2 Support
-
-NPM install
+The `jlpm` command is JupyterLab's pinned version of
+[yarn](https://yarnpkg.com/) that is installed with JupyterLab. You may use
+`yarn` or `npm` in lieu of `jlpm` below.
 
 ```bash
-jupyter labextension install jupyterlab-favorites@2.0.0
-```
-
-### Jupyterlab v1 Support
-
-Via NPM:
-
-```{bash}
-jupyter labextension install jupyterlab-favorites@1.0.0
+# Clone the repo to your local environment
+# Change directory to the jupyterlab_favorites directory
+# Install package in development mode
+pip install -e "."
+# Link your development version of the extension with JupyterLab
+jupyter labextension develop . --overwrite
+# Rebuild extension Typescript source after making changes
+jlpm build
 ```
 
-Or use the tagged 1.0.0 release at:
-https://github.com/jupyterlab-contrib/jupyterlab-favorites/tree/v1.0.0
-
-## Testing
-
-Download Firefox browser if not already installed: https://www.mozilla.org/en-US/firefox/new/
-
-Install Selenium:
+You can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.
 
 ```bash
-conda install -c conda-forge selenium
+# Watch the source directory in one terminal, automatically rebuilding when needed
+jlpm watch
+# Run JupyterLab in another terminal
+jupyter lab
 ```
 
-Install Pytest:
+With the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).
+
+By default, the `jlpm build` command generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:
 
 ```bash
-conda install -c anaconda pytest
+jupyter lab build --minimize=False
 ```
 
-Change directory to this repo after cloning
+### Development uninstall
 
 ```bash
-cd yourfolder/jupyterlab-favorites
+pip uninstall jupyterlab_favorites
 ```
 
-Running test script:
+In development mode, you will also need to remove the symlink created by `jupyter labextension develop`
+command. To find its location, you can run `jupyter labextension list` to figure out where the `labextensions`
+folder is located. Then you can remove the symlink named `@jlab-enhanced/favorites` within that folder.
 
-```bash
-./run_tests.sh
-```
+### Packaging the extension
 
-This will open jupyter lab and run available tests.
-Note: You will need to run in a clean jupyter environment (without existing favorites files)
+See [RELEASE](RELEASE.md)

package/lib/components.d.ts

@@ -1,12 +1,25 @@
-/// <reference types="react" />
-import { ReactWidget } from '@jupyterlab/apputils';
 import { FileBrowser } from '@jupyterlab/filebrowser';
+import { ReactWidget } from '@jupyterlab/ui-components';
+import * as React from 'react';
 import { FavoritesManager } from './manager';
+import { IFavorites } from './token';
+declare namespace types {
+    type FavoriteComponentProps = {
+        favorite: IFavorites.Favorite;
+        handleClick: (favorite: IFavorites.Favorite) => void;
+    };
+    interface IFavoritesBreadCrumbProps {
+        currentPath: string;
+        manager: FavoritesManager;
+        handleClick: (path: string) => void;
+    }
+}
+export declare const FavoritesBreadCrumbs: React.FunctionComponent<types.IFavoritesBreadCrumbProps>;
 export declare class FavoritesWidget extends ReactWidget {
     private manager;
     private filebrowser;
     private pathChanged;
     constructor(manager: FavoritesManager, filebrowser: FileBrowser);
-    handlePinnerClick(path: string): void;
     render(): JSX.Element;
 }
+export {};

package/lib/components.js

@@ -1,8 +1,7 @@
-import { ReactWidget, UseSignal } from '@jupyterlab/apputils';
-import { folderIcon, LabIcon, fileIcon } from '@jupyterlab/ui-components';
+import { folderIcon, LabIcon, fileIcon, ReactWidget, UseSignal } from '@jupyterlab/ui-components';
 import { Signal } from '@lumino/signaling';
 import * as React from 'react';
-import { getFavoritesIcon, getName, getPinnerActionDescription, mergePaths, } from './utils';
+import { getFavoritesIcon, getName, getPinnerActionDescription, mergePaths } from './utils';
 /**
  * The parent node class for Favorites content.
  */
@@ -34,11 +33,6 @@ const FAVORITE_ITEM_TEXT_CLASS = 'jp-Favorites-itemText';
  * When there are no favorited items, this class is hidden.
  */
 const FILEBROWSER_HEADER_CLASS = 'jp-FileBrowser-header';
-/**
- * The class name for the node containing the FileBrowser BreadCrumbs favorite icon.  This node
- * is also responsible for click actions on the icon.
- */
-const FAVORITE_ITEM_PINNER_CLASS = 'jp-Favorites-pinner';
 /**
  * The class name for the the BreadCrumbs favorite icon.
  * This icon is overlaid on top of the FileBrowser content via CSS.
@@ -46,9 +40,14 @@ const FAVORITE_ITEM_PINNER_CLASS = 'jp-Favorites-pinner';
 const FAVORITE_BREADCRUMB_ICON_CLASS = 'jp-Favorites-BreadCrumbs-Icon';
 const FavoriteComponent = (props) => {
     const { favorite, handleClick } = props;
-    let displayName = getName(favorite.path);
+    let [displayName, dirname] = getName(favorite.path);
     if (favorite.name) {
         displayName = favorite.name;
+        // Hide path name if a display name is defined
+        dirname = '';
+    }
+    else {
+        dirname = '/' + dirname;
     }
     let FavoriteIcon;
     if (favorite.iconLabel) {
@@ -63,19 +62,28 @@ const FavoriteComponent = (props) => {
             FavoriteIcon = fileIcon;
         }
     }
-    return (React.createElement("div", { className: FAVORITE_ITEM_CLASS, title: mergePaths(favorite.root, favorite.path), onClick: (e) => {
+    return (React.createElement("div", { className: FAVORITE_ITEM_CLASS, title: mergePaths(favorite.root, favorite.path), onClick: e => {
             handleClick(favorite);
-        } },
+        }, "data-path": favorite.path },
         React.createElement(FavoriteIcon.react, { className: FAVORITE_ITEM_ICON_CLASS, tag: "span" }),
-        React.createElement("span", { className: FAVORITE_ITEM_TEXT_CLASS }, displayName)));
+        React.createElement("span", { className: FAVORITE_ITEM_TEXT_CLASS },
+            displayName,
+            React.createElement("span", { className: "jp-Favorites-dirname" }, dirname))));
 };
-const FavoritesBreadCrumbs = (props) => {
-    if (props.currentPath) {
-        const FavoriteIcon = getFavoritesIcon(props.manager.hasFavorite(props.currentPath));
-        return (React.createElement("div", { className: FAVORITE_ITEM_PINNER_CLASS, title: getPinnerActionDescription(props.manager.hasFavorite(props.currentPath)), onClick: (e) => props.handleClick(props.currentPath) },
-            React.createElement(FavoriteIcon.react, { className: FAVORITE_BREADCRUMB_ICON_CLASS, tag: "span" })));
+export const FavoritesBreadCrumbs = (props) => {
+    const currentPath = props.currentPath;
+    if (!currentPath) {
+        return null;
     }
-    return null;
+    return (React.createElement(UseSignal, { signal: props.manager.favoritesChanged, initialSender: props.manager }, manager => {
+        var _a;
+        const isFavorite = (_a = manager === null || manager === void 0 ? void 0 : manager.hasFavorite(currentPath)) !== null && _a !== void 0 ? _a : false;
+        const icon = getFavoritesIcon(isFavorite);
+        return (React.createElement("button", { className: "jp-ToolbarButtonComponent jp-Button jp-mod-minimal", title: getPinnerActionDescription(isFavorite), onClick: e => {
+                props.handleClick(currentPath);
+            } },
+            React.createElement(icon.react, { className: FAVORITE_BREADCRUMB_ICON_CLASS, tag: "span" })));
+    }));
 };
 export class FavoritesWidget extends ReactWidget {
     constructor(manager, filebrowser) {
@@ -89,27 +97,11 @@ export class FavoritesWidget extends ReactWidget {
             this.pathChanged.emit(path);
         });
     }
-    handlePinnerClick(path) {
-        const shouldRemove = this.manager.hasFavorite(path);
-        if (shouldRemove) {
-            this.manager.removeFavorite(path);
-        }
-        else {
-            const favorite = {
-                root: this.manager.serverRoot,
-                contentType: 'directory',
-                iconLabel: folderIcon.name,
-                path,
-            };
-            this.manager.addFavorite(favorite);
-        }
-    }
     render() {
         return (React.createElement(UseSignal, { signal: this.manager.favoritesChanged, initialSender: this.manager, initialArgs: this.manager.visibleFavorites() }, (manager, visibleFavorites) => (React.createElement("div", null,
             React.createElement(UseSignal, { signal: manager.visibilityChanged, initialSender: manager, initialArgs: manager.isVisible() }, (manager, isVisible) => isVisible && (React.createElement(React.Fragment, null,
                 React.createElement("div", { className: FAVORITE_HEADER_CLASS }, "Favorites"),
-                React.createElement("div", { className: FAVORITE_CONTAINER_CLASS }, visibleFavorites.map((f) => (React.createElement(FavoriteComponent, { key: `favorites-item-${f.path}`, favorite: f, handleClick: manager.handleClick.bind(manager) })))),
-                React.createElement("div", { className: FILEBROWSER_HEADER_CLASS }, "File Browser")))),
-            React.createElement(UseSignal, { signal: this.pathChanged, initialSender: this, initialArgs: this.filebrowser.model.path }, (widget, currentPath) => (React.createElement(FavoritesBreadCrumbs, { currentPath: currentPath, handleClick: widget.handlePinnerClick, manager: widget.manager })))))));
+                React.createElement("div", { className: FAVORITE_CONTAINER_CLASS }, (visibleFavorites !== null && visibleFavorites !== void 0 ? visibleFavorites : []).map(f => (React.createElement(FavoriteComponent, { key: `favorites-item-${f.path}`, favorite: f, handleClick: manager.handleClick.bind(manager) })))),
+                React.createElement("div", { className: FILEBROWSER_HEADER_CLASS }, "File Browser"))))))));
     }
 }

package/lib/icons.js

@@ -3,9 +3,9 @@ import starSvgstr from '../style/icons/md/baseline-star-24px.svg';
 import starBorderSvgstr from '../style/icons/md/baseline-star_border-24px.svg';
 export const filledStarIcon = new LabIcon({
     name: 'jupyterlab-favorites:filledStar',
-    svgstr: starSvgstr,
+    svgstr: starSvgstr
 });
 export const starIcon = new LabIcon({
     name: 'jupyterlab-favorites:star',
-    svgstr: starBorderSvgstr,
+    svgstr: starBorderSvgstr
 });

package/lib/index.d.ts

@@ -1,6 +1,8 @@
 import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+import { IFavorites } from './token';
+export { IFavorites } from './token';
 /**
  * Initialization data for the jupyterlab-favorites extension.
  */
-declare const favorites: JupyterFrontEndPlugin<void>;
+declare const favorites: JupyterFrontEndPlugin<IFavorites>;
 export default favorites;

package/lib/index.js

@@ -1,14 +1,26 @@
-import { IFileBrowserFactory } from '@jupyterlab/filebrowser';
+import { PageConfig } from '@jupyterlab/coreutils';
+import { IDefaultFileBrowser, IFileBrowserFactory } from '@jupyterlab/filebrowser';
 import { IMainMenu } from '@jupyterlab/mainmenu';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
-import { toArray } from '@lumino/algorithm';
-import { FavoritesWidget } from './components';
+import { ReactWidget, UseSignal, folderIcon } from '@jupyterlab/ui-components';
+import { Widget } from '@lumino/widgets';
+import React from 'react';
+import { FavoritesBreadCrumbs, FavoritesWidget } from './components';
 import { starIcon } from './icons';
 import { FavoritesManager } from './manager';
-import { PluginIDs, CommandIDs } from './token';
-import { getFavoritesIcon, getPinnerActionDescription, mergePaths, } from './utils';
-import { PageConfig } from '@jupyterlab/coreutils';
-const TOOLBAR_CLASS = 'jp-FileBrowser-toolbar';
+import { IFavorites, PluginIDs, CommandIDs } from './token';
+import { getFavoritesIcon, getPinnerActionDescription, mergePaths } from './utils';
+import { InputDialog } from '@jupyterlab/apputils';
+export { IFavorites } from './token';
+const BREADCRUMBS_CLASS = 'jp-FileBrowser-crumbs';
+/**
+ * The class name for the node containing the FileBrowser BreadCrumbs favorite icon.
+ */
+const FAVORITE_ITEM_PINNER_CLASS = 'jp-Favorites-pinner';
+/**
+ * Modifier class added to breadcrumbs to ensure the favourite icon has enough spacing.
+ */
+const BREADCUMBS_FAVORITES_CLASS = 'jp-Favorites-crumbs';
 /**
  * Initialization data for the jupyterlab-favorites extension.
  */
@@ -16,36 +28,61 @@ const favorites = {
     id: PluginIDs.favorites,
     autoStart: true,
     requires: [IFileBrowserFactory, ISettingRegistry],
-    optional: [IMainMenu],
-    activate: async (app, factory, settingsRegistry, mainMenu) => {
+    provides: IFavorites,
+    optional: [IDefaultFileBrowser, IMainMenu],
+    activate: (app, factory, settingsRegistry, filebrowser, mainMenu) => {
         console.log('JupyterLab extension jupyterlab-favorites is activated!');
         const docRegistry = app.docRegistry;
-        const filebrowser = factory.defaultBrowser;
-        const layout = filebrowser.layout;
         const { commands, serviceManager } = app;
         const favoritesManager = new FavoritesManager(PageConfig.getOption('serverRoot') || 'Jupyter Server Root', commands, settingsRegistry, serviceManager.contents);
         favoritesManager.init();
-        const favoritesWidget = new FavoritesWidget(favoritesManager, filebrowser);
-        // Insert the Favorites widget contents at the top of the FileBrowser area under the toolbar
-        let insertIndex = 0;
-        layout.widgets.forEach((widget, index) => {
-            if (widget.node.className.includes(TOOLBAR_CLASS)) {
-                insertIndex = index + 1;
-                return; // no reason to continue to iterate once the className is found
+        if (filebrowser) {
+            const favoritesWidget = new FavoritesWidget(favoritesManager, filebrowser);
+            const layout = filebrowser.layout;
+            layout.insertWidget(0, favoritesWidget);
+            const breadcrumbs = filebrowser.node.querySelector(`.${BREADCRUMBS_CLASS}`);
+            if (breadcrumbs) {
+                const initializeBreadcrumbsIcon = () => {
+                    if (!breadcrumbs.isConnected) {
+                        return;
+                    }
+                    filebrowser.model.pathChanged.disconnect(initializeBreadcrumbsIcon);
+                    const favoriteIcon = ReactWidget.create(React.createElement(UseSignal, { signal: filebrowser.model.pathChanged, initialSender: filebrowser.model }, model => (React.createElement(FavoritesBreadCrumbs, { currentPath: (model === null || model === void 0 ? void 0 : model.path) || '', manager: favoritesManager, handleClick: (path) => {
+                            const shouldRemove = favoritesManager.hasFavorite(path);
+                            if (shouldRemove) {
+                                favoritesManager.removeFavorite(path);
+                            }
+                            else {
+                                const favorite = {
+                                    root: favoritesManager.serverRoot,
+                                    contentType: 'directory',
+                                    iconLabel: folderIcon.name,
+                                    path
+                                };
+                                favoritesManager.addFavorite(favorite);
+                            }
+                        } }))));
+                    favoriteIcon.addClass(FAVORITE_ITEM_PINNER_CLASS);
+                    Widget.attach(favoriteIcon, breadcrumbs);
+                    breadcrumbs.insertAdjacentElement('beforebegin', favoriteIcon.node);
+                    breadcrumbs.classList.add(BREADCUMBS_FAVORITES_CLASS);
+                };
+                filebrowser.model.pathChanged.connect(initializeBreadcrumbsIcon);
+                initializeBreadcrumbsIcon();
             }
-        });
-        layout.insertWidget(insertIndex, favoritesWidget);
+        }
         // Context Menu commands
         const getSelectedItems = () => {
             const widget = tracker.currentWidget;
             if (!widget) {
                 return [];
             }
-            return toArray(widget.selectedItems());
+            return Array.from(widget.selectedItems());
         };
         const { tracker } = factory;
         commands.addCommand(CommandIDs.addOrRemoveFavorite, {
             execute: () => {
+                var _a;
                 const selectedItems = getSelectedItems();
                 if (selectedItems.length > 0) {
                     const selectedItem = selectedItems[0];
@@ -59,7 +96,7 @@ const favorites = {
                             root: favoritesManager.serverRoot,
                             path: selectedItem.path,
                             contentType: fileType.contentType,
-                            iconLabel: fileType.icon.name,
+                            iconLabel: (_a = fileType.icon) === null || _a === void 0 ? void 0 : _a.name
                         });
                     }
                 }
@@ -79,81 +116,44 @@ const favorites = {
                 const selectedItem = selectedItems[0];
                 const showRemove = favoritesManager.hasFavorite(selectedItem.path);
                 return getPinnerActionDescription(showRemove);
-            },
-        });
-        app.contextMenu.addItem({
-            command: CommandIDs.addOrRemoveFavorite,
-            selector: '.jp-DirListing-item[data-isdir]',
-            rank: 3,
+            }
         });
         commands.addCommand(CommandIDs.removeFavorite, {
             execute: () => {
-                const contextNode = app.contextMenuHitTest((node) => node.classList.contains('jp-Favorites-item'));
-                const fullPath = contextNode.getAttribute('title');
-                let path = fullPath.replace(favoritesManager.serverRoot, '');
-                if (path.startsWith('/')) {
-                    path = path.slice(1);
-                }
+                const contextNode = app.contextMenuHitTest(node => node.classList.contains('jp-Favorites-item'));
+                const path = contextNode.dataset['path'];
                 favoritesManager.removeFavorite(path);
             },
             icon: starIcon,
-            label: 'Remove Favorite',
-        });
-        app.contextMenu.addItem({
-            command: CommandIDs.removeFavorite,
-            selector: '.jp-Favorites-item',
-            rank: 0,
+            label: 'Remove Favorite'
         });
-        // Main Menu
-        if (mainMenu) {
-            mainMenu.fileMenu.addGroup([
-                {
-                    type: 'submenu',
-                    submenu: favoritesManager.favoritesMenu,
-                },
-            ], 1);
-        }
-        // Try to merge with existing Group 1
-        try {
-            const groups = mainMenu.fileMenu._groups;
-            let numRankOneGroups = 0;
-            let openGroupIndex = -1;
-            for (let i = 0; i < groups.length; i++) {
-                const group = groups[i];
-                if (group.rank === 1) {
-                    numRankOneGroups += 1;
-                    if (openGroupIndex < 0) {
-                        openGroupIndex = i;
-                    }
+        commands.addCommand(CommandIDs.renameFavorite, {
+            execute: async (args) => {
+                var _a;
+                let { path, displayName } = args;
+                if (!path) {
+                    const contextNode = app.contextMenuHitTest(node => node.classList.contains('jp-Favorites-item'));
+                    path = contextNode.dataset['path'];
                 }
-            }
-            if (numRankOneGroups === 2) {
-                const openGroup = groups[openGroupIndex];
-                openGroup.size = openGroup.size + 1;
-                groups.splice(openGroupIndex + 1, 1);
-                const fileMenu = mainMenu.fileMenu.menu;
-                const fileMenuItems = fileMenu._items;
-                let removeSeparators = false;
-                for (let i = fileMenuItems.length - 1; i > 0; i--) {
-                    const fileMenuItem = fileMenuItems[i];
-                    if (fileMenuItem.command === 'filebrowser:open-path') {
-                        break;
-                    }
-                    if (removeSeparators && fileMenuItem.type === 'separator') {
-                        fileMenu.removeItemAt(i);
-                    }
-                    else if (fileMenuItem.type === 'submenu') {
-                        const label = fileMenuItem.submenu.title.label;
-                        if (label === 'Favorites') {
-                            removeSeparators = true;
-                        }
-                    }
+                if (!path) {
+                    return;
                 }
-            }
-        }
-        catch (e) {
-            console.log(e);
-        }
+                if (!displayName) {
+                    const result = await InputDialog.getText({
+                        title: 'Rename favorite',
+                        label: `Name for favorite at '${path}'`,
+                        okLabel: 'Rename',
+                        placeholder: 'Display name'
+                    });
+                    displayName = result.button.accept ? (_a = result.value) !== null && _a !== void 0 ? _a : '' : '';
+                }
+                if (!displayName) {
+                    return;
+                }
+                favoritesManager.renameFavorite(path, displayName);
+            },
+            label: 'Rename Favorite'
+        });
         // Commands
         commands.addCommand(CommandIDs.openFavorite, {
             execute: async (args) => {
@@ -161,30 +161,81 @@ const favorites = {
                 const path = favorite.path === '' ? '/' : favorite.path;
                 await commands.execute('filebrowser:open-path', { path });
             },
-            label: (args) => {
+            label: args => {
                 const favorite = args.favorite;
                 return mergePaths(favorite.root, favorite.path);
-            },
+            }
         });
         commands.addCommand(CommandIDs.toggleFavoritesWidget, {
             execute: async (args) => {
                 const showWidget = args.showWidget;
                 favoritesManager.saveSettings({ showWidget: !showWidget });
             },
-            label: (args) => {
+            label: args => {
                 const showWidget = args.showWidget;
                 return `${showWidget ? 'Hide' : 'Show'} Favorites Widget`;
             },
-            isVisible: () => favoritesManager.visibleFavorites().length > 0,
+            isVisible: () => favoritesManager.visibleFavorites().length > 0
         });
         commands.addCommand(CommandIDs.restoreDefaults, {
             execute: () => favoritesManager.restoreDefaults(),
-            label: 'Restore Defaults',
+            label: 'Restore Defaults'
         });
         commands.addCommand(CommandIDs.clearFavorites, {
             execute: () => favoritesManager.clearFavorites(),
-            label: 'Clear Favorites',
+            label: 'Clear Favorites'
         });
-    },
+        // Main Menu
+        if (mainMenu) {
+            mainMenu.fileMenu.addGroup([
+                {
+                    type: 'submenu',
+                    submenu: favoritesManager.favoritesMenu
+                }
+            ], 1);
+            // Try to merge with existing Group 1
+            try {
+                const groups = mainMenu.fileMenu._ranks;
+                let numRankOneGroups = 0;
+                let openGroupIndex = -1;
+                for (let i = 0; i < groups.length; i++) {
+                    const group = groups[i];
+                    if (group.rank === 1) {
+                        numRankOneGroups += 1;
+                        if (openGroupIndex < 0) {
+                            openGroupIndex = i;
+                        }
+                    }
+                }
+                if (numRankOneGroups === 2) {
+                    const openGroup = groups[openGroupIndex];
+                    openGroup.size = openGroup.size + 1;
+                    groups.splice(openGroupIndex + 1, 1);
+                    const fileMenu = mainMenu.fileMenu.menu;
+                    const fileMenuItems = fileMenu._items;
+                    let removeSeparators = false;
+                    for (let i = fileMenuItems.length - 1; i > 0; i--) {
+                        const fileMenuItem = fileMenuItems[i];
+                        if (fileMenuItem.command === 'filebrowser:open-path') {
+                            break;
+                        }
+                        if (removeSeparators && fileMenuItem.type === 'separator') {
+                            fileMenu.removeItemAt(i);
+                        }
+                        else if (fileMenuItem.type === 'submenu') {
+                            const label = fileMenuItem.submenu.title.label;
+                            if (label === 'Favorites') {
+                                removeSeparators = true;
+                            }
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                console.log(e);
+            }
+        }
+        return favoritesManager;
+    }
 };
 export default favorites;