TypeScript apputils.InstanceTracker类代码示例

      options.forEach(option => {
        let factory = new MimeDocumentFactory({
          renderTimeout: item.renderTimeout,
          dataType: item.dataType,
          rendermime,
          modelName: option.modelName,
          name: option.name,
          primaryFileType: registry.getFileType(option.primaryFileType),
          fileTypes: option.fileTypes,
          defaultFor: option.defaultFor
        });
        registry.addWidgetFactory(factory);

        const factoryName = factory.name;
        const namespace = `${factoryName}-renderer`;
        const tracker = new InstanceTracker<MimeDocument>({ namespace });

        // Handle state restoration.
        restorer.restore(tracker, {
          command: 'docmanager:open',
          args: widget => ({ path: widget.context.path, factory: factoryName }),
          name: widget => widget.context.path
        });

        factory.widgetCreated.connect((sender, widget) => {
          // Notify the instance tracker if restore data needs to update.
          widget.context.pathChanged.connect(() => { tracker.save(widget); });
          tracker.add(widget);
        });
      });

  activate: (app: JupyterLab, palette: ICommandPalette, restorer: ILayoutRestorer): IInspector => {
    const { commands, shell } = app;
    const manager = new InspectorManager();
    const category = 'Inspector';
    const command = CommandIDs.open;
    const label = 'Open Inspector';
    const tracker = new InstanceTracker<InspectorPanel>({
      namespace: 'inspector',
      shell
    });

    /**
     * Create and track a new inspector.
     */
    function newInspectorPanel(): InspectorPanel {
      const inspector = new InspectorPanel();

      inspector.id = 'jp-inspector';
      inspector.title.label = 'Inspector';
      inspector.title.closable = true;
      inspector.disposed.connect(() => {
        if (manager.inspector === inspector) {
          manager.inspector = null;
        }
      });

      // Track the inspector.
      tracker.add(inspector);

      // Add the default inspector child items.
      Private.defaultInspectorItems.forEach(item => { inspector.add(item); });

      return inspector;
    }

    // Handle state restoration.
    restorer.restore(tracker, {
      command,
      args: () => null,
      name: () => 'inspector'
    });

    // Add command to registry and palette.
    commands.addCommand(command, {
      label,
      execute: () => {
        if (!manager.inspector || manager.inspector.isDisposed) {
          manager.inspector = newInspectorPanel();
          shell.addToMainArea(manager.inspector);
        }
        if (manager.inspector.isAttached) {
          tracker.activate(manager.inspector);
        }
      }
    });
    palette.addItem({ command, category });

    return manager;
  }

  describe('RunMenu', () => {
    let commands: CommandRegistry;
    let menu: RunMenu;
    let tracker: InstanceTracker<Wodget>;
    let wodget: Wodget;

    beforeAll(() => {
      commands = new CommandRegistry();
    });

    beforeEach(() => {
      wodget = new Wodget();
      menu = new RunMenu({ commands });
      tracker = new InstanceTracker<Wodget>({ namespace: 'wodget' });
      void tracker.add(wodget);
    });

    afterEach(() => {
      menu.dispose();
      tracker.dispose();
      wodget.dispose();
    });

    describe('#constructor()', () => {
      it('should construct a new run menu', () => {
        expect(menu).to.be.an.instanceof(RunMenu);
        expect(menu.menu.title.label).to.equal('Run');
      });
    });

    describe('#codeRunners', () => {
      it('should allow setting of an ICodeRunner', () => {
        const runner: IRunMenu.ICodeRunner<Wodget> = {
          tracker,
          noun: 'Noun',
          run: widget => {
            widget.state = 'run';
            return Promise.resolve(void 0);
          },
          runAll: widget => {
            widget.state = 'runAll';
            return Promise.resolve(void 0);
          },
          restartAndRunAll: widget => {
            widget.state = 'restartAndRunAll';
            return Promise.resolve(void 0);
          }
        };
        menu.codeRunners.add(runner);
        void delegateExecute(wodget, menu.codeRunners, 'run');
        expect(wodget.state).to.equal('run');
        void delegateExecute(wodget, menu.codeRunners, 'runAll');
        expect(wodget.state).to.equal('runAll');
        void delegateExecute(wodget, menu.codeRunners, 'restartAndRunAll');
        expect(wodget.state).to.equal('restartAndRunAll');
      });
    });
  });

      return promise.then(session => {
        term.session = session;
        tracker.add(term);
        shell.activateById(term.id);

        return term;
      }).catch(() => { term.dispose(); });

        .then(session => {
          term.session = session;
          void tracker.add(main);
          app.shell.activateById(main.id);

          return main;
        })

 factory.widgetCreated.connect((sender, widget) => {
   Private.factoryNameProperty.set(widget, factory.name);
   // Notify the instance tracker if restore data needs to update.
   widget.context.pathChanged.connect(() => {
     void tracker.save(widget);
   });
   void tracker.add(widget);
 });

 execute: () => {
   let options = Terminal.defaultOptions;
   if (options.fontSize < 72) {
     options.fontSize++;
     tracker.forEach(widget => {
       widget.content.fontSize = options.fontSize;
     });
   }
 },

 execute: () => {
   if (!manager.inspector || manager.inspector.isDisposed) {
     manager.inspector = newInspectorPanel();
     shell.addToMainArea(manager.inspector);
   }
   if (manager.inspector.isAttached) {
     tracker.activate(manager.inspector);
   }
 }

 execute: () => {
   tracker.forEach(widget => {
     if (widget.theme === 'dark') {
       widget.theme = 'light';
     } else {
       widget.theme = 'dark';
     }
   });
 },