TypeScript docmanager.DocumentManager类代码示例

function createApp(manager: ServiceManager.IManager): void {
  // Initialize the command registry with the bindings.
  let commands = new CommandRegistry();
  let useCapture = true;

  // Setup the keydown listener for the document.
  document.addEventListener(
    'keydown',
    event => {
      commands.processKeydownEvent(event);
    },
    useCapture
  );

  let rendermime = new RenderMimeRegistry({ initialFactories });

  let opener = {
    open: (widget: Widget) => {
      // Do nothing for sibling widgets for now.
    }
  };

  let docRegistry = new DocumentRegistry();
  let docManager = new DocumentManager({
    registry: docRegistry,
    manager,
    opener
  });
  let mFactory = new NotebookModelFactory({});
  let editorFactory = editorServices.factoryService.newInlineEditor;
  let contentFactory = new NotebookPanel.ContentFactory({ editorFactory });

  let wFactory = new NotebookWidgetFactory({
    name: 'Notebook',
    modelName: 'notebook',
    fileTypes: ['notebook'],
    defaultFor: ['notebook'],
    preferKernel: true,
    canStartKernel: true,
    rendermime,
    contentFactory,
    mimeTypeService: editorServices.mimeTypeService
  });
  docRegistry.addModelFactory(mFactory);
  docRegistry.addWidgetFactory(wFactory);

  let nbWidget = docManager.open(NOTEBOOK) as NotebookPanel;
  let palette = new CommandPalette({ commands });

  const editor =
    nbWidget.content.activeCell && nbWidget.content.activeCell.editor;
  const model = new CompleterModel();
  const completer = new Completer({ editor, model });
  const connector = new KernelConnector({ session: nbWidget.session });
  const handler = new CompletionHandler({ completer, connector });

  // Set the handler's editor.
  handler.editor = editor;

  // Listen for active cell changes.
  nbWidget.content.activeCellChanged.connect((sender, cell) => {
    handler.editor = cell && cell.editor;
  });

  // Hide the widget when it first loads.
  completer.hide();

  let panel = new SplitPanel();
  panel.id = 'main';
  panel.orientation = 'horizontal';
  panel.spacing = 0;
  SplitPanel.setStretch(palette, 0);
  SplitPanel.setStretch(nbWidget, 1);
  panel.addWidget(completer);
  panel.addWidget(palette);
  panel.addWidget(nbWidget);

  // Attach the panel to the DOM.
  Widget.attach(panel, document.body);

  // Handle resize events.
  window.addEventListener('resize', () => {
    panel.update();
  });

  // Add commands.
  commands.addCommand(cmdIds.invoke, {
    label: 'Completer: Invoke',
    execute: () => handler.invoke()
  });
  commands.addCommand(cmdIds.select, {
    label: 'Completer: Select',
    execute: () => handler.completer.selectActive()
  });
  commands.addCommand(cmdIds.invokeNotebook, {
    label: 'Invoke Notebook',
    execute: () => {
      if (nbWidget.content.activeCell.model.type === 'code') {
        return commands.execute(cmdIds.invoke);
      }
//.........这里部分代码省略.........

describe('@jupyterlab/docmanager', () => {

  let manager: DocumentManager;
  let services: ServiceManager.IManager;
  let context: DocumentRegistry.Context;
  let widget: Widget;
  let textModelFactory = new TextModelFactory();
  let widgetFactory = new WidgetFactory({
    name: 'test',
    fileTypes: ['text'],
    canStartKernel: true,
    preferKernel: true
  });
  let openedWidget: Widget;

  before(() => {
    services = new ServiceManager();
    return services.ready;
  });

  beforeEach(() => {
    let registry = new DocumentRegistry({ textModelFactory });
    registry.addWidgetFactory(widgetFactory);
    DocumentRegistry.defaultFileTypes.forEach(ft => {
      registry.addFileType(ft);
    });
    manager = new DocumentManager({
      registry,
      manager: services,
      opener: {
        open: (widget: Widget) => {
          openedWidget = widget;
        }
      }
    });
  });

  afterEach(() => {
    manager.dispose();
  });

  describe('DocumentWidgetManager', () => {

    describe('#constructor()', () => {

      it('should create a new document manager', () => {
        expect(manager).to.be.a(DocumentManager);
      });

    });

    describe('#isDisposed', () => {

      it('should test whether the manager is disposed', () => {
        expect(manager.isDisposed).to.be(false);
        manager.dispose();
        expect(manager.isDisposed).to.be(true);
      });

    });

    describe('#dispose()', () => {

      it('should dispose of the resources used by the manager', () => {
        expect(manager.isDisposed).to.be(false);
        manager.dispose();
        expect(manager.isDisposed).to.be(true);
        manager.dispose();
        expect(manager.isDisposed).to.be(true);
      });

    });

    describe('#services', () => {

      it('should get the service manager for the manager', () => {
        expect(manager.services).to.be.a(ServiceManager);
      });

    });

    describe('#registry', () => {

      it('should get the registry used by the manager', () => {
        expect(manager.registry).to.be.a(DocumentRegistry);
      });

    });

    describe('#open()', () => {

      it('should open a file and return the widget used to view it', () => {
        return services.contents.newUntitled({ type: 'file', ext: '.txt'}).then(model => {
          widget = manager.open(model.path);
          expect(widget.hasClass('WidgetFactory')).to.be(true);
          return dismissDialog();
        });
      });

      it('should start a kernel if one is given', () => {
//.........这里部分代码省略.........

 .then(model => {
   widget = manager.createNew(model.path);
   expect(widget.hasClass('WidgetFactory')).to.be(true);
   return dismissDialog();
 });

 it('should test whether the manager is disposed', () => {
   expect(manager.isDisposed).to.be(false);
   manager.dispose();
   expect(manager.isDisposed).to.be(true);
 });

 }).then(() => {
   return manager.closeAll();
 }).then(() => {

 return services.contents.newUntitled({ type: 'file', ext: '.txt'}).then(model => {
   path = model.path;
   let widget0 = manager.createNew(path);
   widget0.disposed.connect(() => { called++; });
   return dismissDialog();
 }).then(() => {

 it('should fail to find a widget', () => {
   expect(manager.findWidget('foo')).to.be.undefined;
 });