activate: (
   app: JupyterFrontEnd,
   statusBar: IStatusBar,
   tracker: IEditorTracker,
   labShell: ILabShell
 ) => {
   let item = new EditorSyntaxStatus({ commands: app.commands });
   labShell.currentChanged.connect(() => {
     const current = labShell.currentWidget;
     if (current && tracker.has(current)) {
       item.model.editor = (current as IDocumentWidget<
         FileEditor
       >).content.editor;
     }
   });
   statusBar.registerStatusItem(
     '@jupyterlab/codemirror-extension:editor-syntax-status',
     {
       item,
       align: 'left',
       rank: 0,
       isActive: () =>
         labShell.currentWidget &&
         tracker.currentWidget &&
         labShell.currentWidget === tracker.currentWidget
     }
   );
 }

  activate: (
    app: JupyterFrontEnd,
    statusBar: IStatusBar,
    editorTracker: IEditorTracker,
    settingRegistry: ISettingRegistry
  ) => {
    // Create a menu for switching tabs vs spaces.
    const menu = new Menu({ commands: app.commands });
    const command = 'fileeditor:change-tabs';
    const { shell } = app;
    const args: JSONObject = {
      insertSpaces: false,
      size: 4,
      name: 'Indent with Tab'
    };
    menu.addItem({ command, args });
    for (let size of [1, 2, 4, 8]) {
      let args: JSONObject = {
        insertSpaces: true,
        size,
        name: `Spaces: ${size} `
      };
      menu.addItem({ command, args });
    }

    // Create the status item.
    const item = new TabSpaceStatus({ menu });

    // Keep a reference to the code editor config from the settings system.
    const updateSettings = (settings: ISettingRegistry.ISettings): void => {
      const cached = settings.get('editorConfig').composite as Partial<
        CodeEditor.IConfig
      >;
      const config: CodeEditor.IConfig = {
        ...CodeEditor.defaultConfig,
        ...cached
      };
      item.model!.config = config;
    };
    void Promise.all([
      settingRegistry.load('@jupyterlab/fileeditor-extension:plugin'),
      app.restored
    ]).then(([settings]) => {
      updateSettings(settings);
      settings.changed.connect(updateSettings);
    });

    // Add the status item.
    statusBar.registerStatusItem(
      '@jupyterlab/fileeditor-extension:tab-space-status',
      {
        item,
        align: 'right',
        rank: 1,
        isActive: () => {
          return shell.currentWidget && editorTracker.has(shell.currentWidget);
        }
      }
    );
  }

  activate: (
    app: JupyterLab,
    statusBar: IStatusBar,
    docManager: IDocumentManager
  ) => {
    let item = new PathStatus({ docManager });

    // Keep the file path widget up-to-date with the application active widget.
    item.model!.widget = app.shell.currentWidget;
    app.shell.currentChanged.connect(() => {
      item.model!.widget = app.shell.currentWidget;
    });

    statusBar.registerStatusItem(
      '@jupyterlab/docmanager-extension:path-status',
      {
        item,
        align: 'right',
        rank: 0,
        isActive: () => {
          return true;
        }
      }
    );
  }

  activate: (
    app: JupyterLab,
    statusBar: IStatusBar,
    docManager: IDocumentManager
  ) => {
    let item = new SavingStatus({ docManager });

    // Keep the currently active widget synchronized.
    item.model!.widget = app.shell.currentWidget;
    app.shell.currentChanged.connect(
      () => (item.model!.widget = app.shell.currentWidget)
    );

    statusBar.registerStatusItem(
      '@jupyterlab.docmanager-extension:saving-status',
      {
        item,
        align: 'middle',
        isActive: () => {
          return true;
        },
        activeStateChanged: item.model!.stateChanged
      }
    );
  }

  activate: (app: JupyterLab, statusBar: IStatusBar) => {
    let item = new MemoryUsage();

    statusBar.registerStatusItem(
      '@jupyterlab/statusbar-extension:memory-usage-status',
      {
        item,
        align: 'left',
        rank: 2,
        isActive: () => item.model!.metricsAvailable,
        activeStateChanged: item.model!.stateChanged
      }
    );
  }

  activate: (app: JupyterLab, statusBar: IStatusBar) => {
    const item = new RunningSessions({
      onClick: () => app.shell.activateById('jp-running-sessions'),
      serviceManager: app.serviceManager
    });

    statusBar.registerStatusItem(
      '@jupyterlab/statusbar-extension:running-sessions-status',
      {
        item,
        align: 'left',
        rank: 0
      }
    );
  }

  activate: (
    app: JupyterFrontEnd,
    statusBar: IStatusBar,
    browser: IFileBrowserFactory
  ) => {
    const item = new FileUploadStatus({
      tracker: browser.tracker
    });

    statusBar.registerStatusItem(
      '@jupyterlab/filebrowser-extension:file-upload-status',
      {
        item,
        align: 'middle',
        isActive: () => {
          return !!item.model && item.model.items.length > 0;
        },
        activeStateChanged: item.model.stateChanged
      }
    );
  }

  activate: (
    _: JupyterFrontEnd,
    statusBar: IStatusBar,
    docManager: IDocumentManager,
    labShell: ILabShell
  ) => {
    const path = new PathStatus({ docManager });

    // Keep the file path widget up-to-date with the application active widget.
    path.model!.widget = labShell.currentWidget;
    labShell.currentChanged.connect(() => {
      path.model!.widget = labShell.currentWidget;
    });

    statusBar.registerStatusItem(pathStatusPlugin.id, {
      item: path,
      align: 'right',
      rank: 0,
      isActive: () => true
    });
  }

  activate: (
    _: JupyterFrontEnd,
    statusBar: IStatusBar,
    docManager: IDocumentManager,
    labShell: ILabShell
  ) => {
    const saving = new SavingStatus({ docManager });

    // Keep the currently active widget synchronized.
    saving.model!.widget = labShell.currentWidget;
    labShell.currentChanged.connect(() => {
      saving.model!.widget = labShell.currentWidget;
    });

    statusBar.registerStatusItem(savingStatusPlugin.id, {
      item: saving,
      align: 'middle',
      isActive: () => true,
      activeStateChanged: saving.model!.stateChanged
    });
  }

  activate: (
    app: JupyterLab,
    statusBar: IStatusBar,
    notebookTracker: INotebookTracker,
    consoleTracker: IConsoleTracker
  ) => {
    // When the status item is clicked, launch the kernel
    // selection dialog for the current session.
    let currentSession: IClientSession | null = null;
    const changeKernel = () => {
      if (!currentSession) {
        return;
      }
      currentSession.selectKernel();
    };

    // Create the status item.
    const item = new KernelStatus({
      onClick: changeKernel
    });

    // When the title of the active widget changes, update the label
    // of the hover text.
    const onTitleChanged = (title: Title<Widget>) => {
      item.model!.activityName = title.label;
    };

    // Keep the session object on the status item up-to-date.
    app.shell.currentChanged.connect((shell, change) => {
      const { oldValue, newValue } = change;

      // Clean up after the old value if it exists,
      // listen for changes to the title of the activity
      if (oldValue) {
        oldValue.title.changed.disconnect(onTitleChanged);
      }
      if (newValue) {
        newValue.title.changed.connect(onTitleChanged);
      }

      // Grab the session off of the current widget, if it exists.
      if (newValue && consoleTracker.has(newValue)) {
        currentSession = (newValue as ConsolePanel).session;
      } else if (newValue && notebookTracker.has(newValue)) {
        currentSession = (newValue as NotebookPanel).session;
      } else {
        currentSession = null;
      }
      item.model!.session = currentSession;
    });

    statusBar.registerStatusItem(
      '@jupyterlab/statusbar-extension:kernel-status',
      {
        item,
        align: 'left',
        rank: 1,
        isActive: () => {
          const current = app.shell.currentWidget;
          return (
            current &&
            (notebookTracker.has(current) || consoleTracker.has(current))
          );
        }
      }
    );
  }