@jupyterlab/fileeditor 4.0.0-alpha.2 → 4.0.0-alpha.20

package/src/tabspacestatus.tsx

@@ -0,0 +1,166 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { Popup, showPopup, TextItem } from '@jupyterlab/statusbar';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+import { VDomModel, VDomRenderer } from '@jupyterlab/ui-components';
+import { Menu } from '@lumino/widgets';
+import React from 'react';
+
+/**
+ * A namespace for TabSpaceComponent statics.
+ */
+namespace TabSpaceComponent {
+  /**
+   * The props for TabSpaceComponent.
+   */
+  export interface IProps {
+    /**
+     * The number of spaces for indentation.
+     *
+     * `null` means use tab character for indentation.
+     */
+    tabSpace: number | null;
+
+    /**
+     * The application language translator.
+     */
+    translator?: ITranslator;
+
+    /**
+     * A click handler for the TabSpace component. By default
+     * opens a menu allowing the user to select tabs vs spaces.
+     */
+    handleClick: () => void;
+  }
+}
+
+/**
+ * A pure functional component for rendering the TabSpace status.
+ */
+function TabSpaceComponent(
+  props: TabSpaceComponent.IProps
+): React.ReactElement<TabSpaceComponent.IProps> {
+  const translator = props.translator || nullTranslator;
+  const trans = translator.load('jupyterlab');
+  const description =
+    typeof props.tabSpace === 'number'
+      ? trans.__('Spaces')
+      : trans.__('Tab Indent');
+  return (
+    <TextItem
+      onClick={props.handleClick}
+      source={
+        typeof props.tabSpace === 'number'
+          ? `${description}: ${props.tabSpace}`
+          : description
+      }
+      title={trans.__('Change the indentation…')}
+    />
+  );
+}
+
+/**
+ * A VDomRenderer for a tabs vs. spaces status item.
+ */
+export class TabSpaceStatus extends VDomRenderer<TabSpaceStatus.Model> {
+  /**
+   * Create a new tab/space status item.
+   */
+  constructor(options: TabSpaceStatus.IOptions) {
+    super(new TabSpaceStatus.Model());
+    this._menu = options.menu;
+    this.translator = options.translator || nullTranslator;
+    this.addClass('jp-mod-highlighted');
+  }
+
+  /**
+   * Render the TabSpace status item.
+   */
+  render(): React.ReactElement<TabSpaceComponent.IProps> | null {
+    if (!this.model?.indentUnit) {
+      return null;
+    } else {
+      const tabSpace =
+        this.model.indentUnit === 'Tab'
+          ? null
+          : parseInt(this.model.indentUnit, 10);
+      return (
+        <TabSpaceComponent
+          tabSpace={tabSpace}
+          handleClick={() => this._handleClick()}
+          translator={this.translator}
+        />
+      );
+    }
+  }
+
+  /**
+   * Handle a click on the status item.
+   */
+  private _handleClick(): void {
+    const menu = this._menu;
+    if (this._popup) {
+      this._popup.dispose();
+    }
+
+    menu.aboutToClose.connect(this._menuClosed, this);
+
+    this._popup = showPopup({
+      body: menu,
+      anchor: this,
+      align: 'right'
+    });
+    // Update the menu items
+    menu.update();
+  }
+
+  private _menuClosed(): void {
+    this.removeClass('jp-mod-clicked');
+  }
+
+  protected translator: ITranslator;
+  private _menu: Menu;
+  private _popup: Popup | null = null;
+}
+
+/**
+ * A namespace for TabSpace statics.
+ */
+export namespace TabSpaceStatus {
+  /**
+   * A VDomModel for the TabSpace status item.
+   */
+  export class Model extends VDomModel {
+    /**
+     * Code editor indentation unit
+     */
+    get indentUnit(): string | null {
+      return this._indentUnit;
+    }
+    set indentUnit(v: string | null) {
+      if (v !== this._indentUnit) {
+        this._indentUnit = v;
+        this.stateChanged.emit();
+      }
+    }
+
+    private _indentUnit: string | null;
+  }
+
+  /**
+   * Options for creating a TabSpace status item.
+   */
+  export interface IOptions {
+    /**
+     * A menu to open when clicking on the status item. This should allow
+     * the user to make a different selection about tabs/spaces.
+     */
+    menu: Menu;
+
+    /**
+     * Language translator.
+     */
+    translator?: ITranslator;
+  }
+}

package/src/toc/factory.ts

@@ -0,0 +1,72 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { DocumentRegistry, IDocumentWidget } from '@jupyterlab/docregistry';
+import {
+  TableOfContents,
+  TableOfContentsFactory,
+  TableOfContentsModel
+} from '@jupyterlab/toc';
+import { FileEditor } from '../widget';
+
+/**
+ * Interface describing a file editor heading.
+ */
+export interface IEditorHeading extends TableOfContents.IHeading {
+  /**
+   * Heading line number.
+   */
+  line: number;
+}
+
+/**
+ * Base table of contents model factory for file editor
+ */
+export abstract class EditorTableOfContentsFactory extends TableOfContentsFactory<
+  IDocumentWidget<FileEditor>
+> {
+  /**
+   * Create a new table of contents model for the widget
+   *
+   * @param widget - widget
+   * @param configuration - Table of contents configuration
+   * @returns The table of contents model
+   */
+  createNew(
+    widget: IDocumentWidget<FileEditor, DocumentRegistry.IModel>,
+    configuration?: TableOfContents.IConfig
+  ): TableOfContentsModel<
+    IEditorHeading,
+    IDocumentWidget<FileEditor, DocumentRegistry.IModel>
+  > {
+    const model = super.createNew(
+      widget,
+      configuration
+    ) as TableOfContentsModel<
+      IEditorHeading,
+      IDocumentWidget<FileEditor, DocumentRegistry.IModel>
+    >;
+
+    const onActiveHeadingChanged = (
+      model: TableOfContentsModel<
+        IEditorHeading,
+        IDocumentWidget<FileEditor, DocumentRegistry.IModel>
+      >,
+      heading: IEditorHeading | null
+    ) => {
+      if (heading) {
+        widget.content.editor.setCursorPosition({
+          line: heading.line,
+          column: 0
+        });
+      }
+    };
+
+    model.activeHeadingChanged.connect(onActiveHeadingChanged);
+    widget.disposed.connect(() => {
+      model.activeHeadingChanged.disconnect(onActiveHeadingChanged);
+    });
+
+    return model;
+  }
+}

package/src/toc/index.ts

@@ -0,0 +1,7 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+export * from './factory';
+export * from './latex';
+export * from './markdown';
+export * from './python';

package/src/toc/latex.ts

@@ -0,0 +1,145 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { DocumentRegistry, IDocumentWidget } from '@jupyterlab/docregistry';
+import {
+  TableOfContents,
+  TableOfContentsModel,
+  TableOfContentsUtils
+} from '@jupyterlab/toc';
+import { Widget } from '@lumino/widgets';
+import { FileEditor } from '../widget';
+import { EditorTableOfContentsFactory, IEditorHeading } from './factory';
+
+/**
+ * Maps LaTeX section headings to HTML header levels.
+ *
+ * ## Notes
+ *
+ * -   As `part` and `chapter` section headings appear to be less common, assign them to heading level 1.
+ *
+ * @private
+ */
+const LATEX_LEVELS: { [label: string]: number } = {
+  part: 1, // Only available for report and book classes
+  chapter: 1, // Only available for report and book classes
+  section: 1,
+  subsection: 2,
+  subsubsection: 3,
+  paragraph: 4,
+  subparagraph: 5
+};
+
+/**
+ * Regular expression to create the outline
+ */
+const SECTIONS = /^\s*\\(section|subsection|subsubsection){(.+)}/;
+
+/**
+ * Table of content model for LaTeX files.
+ */
+export class LaTeXTableOfContentsModel extends TableOfContentsModel<
+  IEditorHeading,
+  IDocumentWidget<FileEditor, DocumentRegistry.IModel>
+> {
+  /**
+   * Type of document supported by the model.
+   *
+   * #### Notes
+   * A `data-document-type` attribute with this value will be set
+   * on the tree view `.jp-TableOfContents-content[data-document-type="..."]`
+   */
+  get documentType(): string {
+    return 'latex';
+  }
+
+  /**
+   * List of configuration options supported by the model.
+   */
+  get supportedOptions(): (keyof TableOfContents.IConfig)[] {
+    return ['maximalDepth', 'numberHeaders'];
+  }
+
+  /**
+   * Produce the headings for a document.
+   *
+   * @returns The list of new headings or `null` if nothing needs to be updated.
+   */
+  protected getHeadings(): Promise<IEditorHeading[] | null> {
+    if (!this.isActive) {
+      return Promise.resolve(null);
+    }
+
+    // Split the text into lines:
+    const lines = this.widget.content.model.sharedModel
+      .getSource()
+      .split('\n') as Array<string>;
+
+    const levels = new Array<number>();
+    let previousLevel = levels.length;
+    const headings = new Array<IEditorHeading>();
+    for (let i = 0; i < lines.length; i++) {
+      const match = lines[i].match(SECTIONS);
+      if (match) {
+        const level = LATEX_LEVELS[match[1]];
+        if (level <= this.configuration.maximalDepth) {
+          const prefix = TableOfContentsUtils.getPrefix(
+            level,
+            previousLevel,
+            levels,
+            {
+              ...this.configuration,
+              // Force base numbering and numbering first level
+              baseNumbering: 1,
+              numberingH1: true
+            }
+          );
+          previousLevel = level;
+
+          headings.push({
+            text: match[2],
+            prefix: prefix,
+            level,
+            line: i
+          });
+        }
+      }
+    }
+    return Promise.resolve(headings);
+  }
+}
+
+/**
+ * Table of content model factory for LaTeX files.
+ */
+export class LaTeXTableOfContentsFactory extends EditorTableOfContentsFactory {
+  /**
+   * Whether the factory can handle the widget or not.
+   *
+   * @param widget - widget
+   * @returns boolean indicating a ToC can be generated
+   */
+  isApplicable(widget: Widget): boolean {
+    const isApplicable = super.isApplicable(widget);
+
+    if (isApplicable) {
+      let mime = (widget as any).content?.model?.mimeType;
+      return mime && (mime === 'text/x-latex' || mime === 'text/x-stex');
+    }
+    return false;
+  }
+
+  /**
+   * Create a new table of contents model for the widget
+   *
+   * @param widget - widget
+   * @param configuration - Table of contents configuration
+   * @returns The table of contents model
+   */
+  protected _createNew(
+    widget: IDocumentWidget<FileEditor, DocumentRegistry.IModel>,
+    configuration?: TableOfContents.IConfig
+  ): LaTeXTableOfContentsModel {
+    return new LaTeXTableOfContentsModel(widget, configuration);
+  }
+}

package/src/toc/markdown.ts

@@ -0,0 +1,90 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { DocumentRegistry, IDocumentWidget } from '@jupyterlab/docregistry';
+import {
+  TableOfContents,
+  TableOfContentsModel,
+  TableOfContentsUtils
+} from '@jupyterlab/toc';
+import { Widget } from '@lumino/widgets';
+import { FileEditor } from '../widget';
+import { EditorTableOfContentsFactory, IEditorHeading } from './factory';
+
+/**
+ * Table of content model for Markdown files.
+ */
+export class MarkdownTableOfContentsModel extends TableOfContentsModel<
+  IEditorHeading,
+  IDocumentWidget<FileEditor, DocumentRegistry.IModel>
+> {
+  /**
+   * Type of document supported by the model.
+   *
+   * #### Notes
+   * A `data-document-type` attribute with this value will be set
+   * on the tree view `.jp-TableOfContents-content[data-document-type="..."]`
+   */
+  get documentType(): string {
+    return 'markdown';
+  }
+
+  /**
+   * Produce the headings for a document.
+   *
+   * @returns The list of new headings or `null` if nothing needs to be updated.
+   */
+  protected getHeadings(): Promise<IEditorHeading[] | null> {
+    if (!this.isActive) {
+      return Promise.resolve(null);
+    }
+
+    const content = this.widget.content.model.sharedModel.getSource();
+
+    const headings = TableOfContentsUtils.filterHeadings(
+      TableOfContentsUtils.Markdown.getHeadings(content),
+      {
+        ...this.configuration,
+        // Force removing numbering as they cannot be displayed
+        // in the document
+        numberHeaders: false
+      }
+    );
+    return Promise.resolve(headings);
+  }
+}
+
+/**
+ * Table of content model factory for Markdown files.
+ */
+export class MarkdownTableOfContentsFactory extends EditorTableOfContentsFactory {
+  /**
+   * Whether the factory can handle the widget or not.
+   *
+   * @param widget - widget
+   * @returns boolean indicating a ToC can be generated
+   */
+  isApplicable(widget: Widget): boolean {
+    const isApplicable = super.isApplicable(widget);
+
+    if (isApplicable) {
+      let mime = (widget as any).content?.model?.mimeType;
+      return mime && TableOfContentsUtils.Markdown.isMarkdown(mime);
+    }
+    return false;
+  }
+
+  /**
+   * Create a new table of contents model for the widget
+   *
+   * @param widget - widget
+   * @param configuration - Table of contents configuration
+   * @returns The table of contents model
+   */
+  protected _createNew(
+    widget: IDocumentWidget<FileEditor, DocumentRegistry.IModel>,
+    configuration?: TableOfContents.IConfig
+  ): MarkdownTableOfContentsModel {
+    return new MarkdownTableOfContentsModel(widget, configuration);
+  }
+}

package/src/toc/python.ts

@@ -0,0 +1,143 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+/*eslint no-invalid-regexp: ["error", { "allowConstructorFlags": ["d"] }]*/
+
+import { DocumentRegistry, IDocumentWidget } from '@jupyterlab/docregistry';
+import { TableOfContents, TableOfContentsModel } from '@jupyterlab/toc';
+import { Widget } from '@lumino/widgets';
+import { FileEditor } from '../widget';
+import { EditorTableOfContentsFactory, IEditorHeading } from './factory';
+
+/**
+ * Regular expression to create the outline
+ */
+let KEYWORDS: RegExp;
+try {
+  // https://github.com/tc39/proposal-regexp-match-indices was accepted
+  // in May 2021 (https://github.com/tc39/proposals/blob/main/finished-proposals.md)
+  // So we will fallback to the polyfill regexp-match-indices if not available
+  KEYWORDS = new RegExp('^\\s*(class |def |from |import )', 'd');
+} catch {
+  KEYWORDS = new RegExp('^\\s*(class |def |from |import )');
+}
+
+/**
+ * Table of content model for Python files.
+ */
+export class PythonTableOfContentsModel extends TableOfContentsModel<
+  IEditorHeading,
+  IDocumentWidget<FileEditor, DocumentRegistry.IModel>
+> {
+  /**
+   * Type of document supported by the model.
+   *
+   * #### Notes
+   * A `data-document-type` attribute with this value will be set
+   * on the tree view `.jp-TableOfContents-content[data-document-type="..."]`
+   */
+  get documentType(): string {
+    return 'python';
+  }
+
+  /**
+   * Produce the headings for a document.
+   *
+   * @returns The list of new headings or `null` if nothing needs to be updated.
+   */
+  protected async getHeadings(): Promise<IEditorHeading[] | null> {
+    if (!this.isActive) {
+      return Promise.resolve(null);
+    }
+
+    // Split the text into lines:
+    const lines = this.widget.content.model.sharedModel
+      .getSource()
+      .split('\n') as Array<string>;
+
+    // Iterate over the lines to get the heading level and text for each line:
+    let headings = new Array<IEditorHeading>();
+    let processingImports = false;
+
+    let indent = 1;
+
+    let lineIdx = -1;
+    for (const line of lines) {
+      lineIdx++;
+      let hasKeyword: RegExpExecArray | null;
+      if (KEYWORDS.flags.includes('d')) {
+        hasKeyword = KEYWORDS.exec(line);
+      } else {
+        const { default: execWithIndices } = await import(
+          'regexp-match-indices'
+        );
+        hasKeyword = execWithIndices(KEYWORDS, line);
+      }
+      if (hasKeyword) {
+        // Index 0 contains the spaces, index 1 is the keyword group
+        const [start] = (hasKeyword as any).indices[1];
+        if (indent === 1 && start > 0) {
+          indent = start;
+        }
+
+        const isImport = ['from ', 'import '].includes(hasKeyword[1]);
+        if (isImport && processingImports) {
+          continue;
+        }
+        processingImports = isImport;
+
+        const level = 1 + start / indent;
+
+        if (level > this.configuration.maximalDepth) {
+          continue;
+        }
+
+        headings.push({
+          text: line.slice(start),
+          level,
+          line: lineIdx
+        });
+      }
+    }
+
+    return Promise.resolve(headings);
+  }
+}
+
+/**
+ * Table of content model factory for Python files.
+ */
+export class PythonTableOfContentsFactory extends EditorTableOfContentsFactory {
+  /**
+   * Whether the factory can handle the widget or not.
+   *
+   * @param widget - widget
+   * @returns boolean indicating a ToC can be generated
+   */
+  isApplicable(widget: Widget): boolean {
+    const isApplicable = super.isApplicable(widget);
+
+    if (isApplicable) {
+      let mime = (widget as any).content?.model?.mimeType;
+      return (
+        mime &&
+        (mime === 'application/x-python-code' || mime === 'text/x-python')
+      );
+    }
+    return false;
+  }
+
+  /**
+   * Create a new table of contents model for the widget
+   *
+   * @param widget - widget
+   * @param configuration - Table of contents configuration
+   * @returns The table of contents model
+   */
+  protected _createNew(
+    widget: IDocumentWidget<FileEditor>,
+    configuration?: TableOfContents.IConfig
+  ): PythonTableOfContentsModel {
+    return new PythonTableOfContentsModel(widget, configuration);
+  }
+}

package/src/tokens.ts

@@ -0,0 +1,20 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { IWidgetTracker } from '@jupyterlab/apputils';
+import { IDocumentWidget } from '@jupyterlab/docregistry';
+import { Token } from '@lumino/coreutils';
+import { FileEditor } from './widget';
+
+/**
+ * A class that tracks editor widgets.
+ */
+export interface IEditorTracker
+  extends IWidgetTracker<IDocumentWidget<FileEditor>> {}
+
+/**
+ * The editor tracker token.
+ */
+export const IEditorTracker = new Token<IEditorTracker>(
+  '@jupyterlab/fileeditor:IEditorTracker'
+);