TypeScript PromiseDelegate.resolve方法代码示例

 it('should fetch saved data', async () => {
   const ready = new PromiseDelegate<void>();
   const restorer = new LayoutRestorer({
     first: ready.promise,
     registry: new CommandRegistry(),
     state: new StateDB({ namespace: NAMESPACE })
   });
   const currentWidget = new Widget();
   // The `fresh` attribute is only here to check against the return value.
   const dehydrated: ILabShell.ILayout = {
     fresh: false,
     mainArea: { currentWidget: null, dock: null, mode: null },
     leftArea: {
       currentWidget,
       collapsed: true,
       widgets: [currentWidget]
     },
     rightArea: { collapsed: true, currentWidget: null, widgets: null }
   };
   restorer.add(currentWidget, 'test-one');
   ready.resolve(void 0);
   await restorer.restored;
   await restorer.save(dehydrated);
   const layout = await restorer.fetch();
   expect(layout).to.deep.equal(dehydrated);
 });

      execute: (args: IRouter.ILocation) => {
        const { hash, path, search } = args;
        const query = URLExt.queryStringToObject(search || '');
        const reset = 'reset' in query;

        if (!reset) {
          return;
        }

        // If the state database has already been resolved, resetting is
        // impossible without reloading.
        if (resolved) {
          return document.location.reload();
        }

        // Empty the state database.
        resolved = true;
        transform.resolve({ type: 'clear', contents: null });

        // Maintain the query string parameters but remove `reset`.
        delete query['reset'];

        const url = path + URLExt.objectToQueryString(query) + hash;
        const cleared = commands.execute(CommandIDs.recoverState)
          .then(() => router.stop); // Stop routing before new route navigation.

        // After the state has been reset, navigate to the URL.
        cleared.then(() => { router.navigate(url, { silent: true }); });

        return cleared;
      }

      it('should restore the widgets in a tracker', done => {
        let tracker = new InstanceTracker<Widget>({
          namespace: 'foo-widget',
          shell: new ApplicationShell()
        });
        let registry = new CommandRegistry();
        let state = new StateDB({ namespace: NAMESPACE });
        let ready = new PromiseDelegate<void>();
        let restorer = new LayoutRestorer({
          first: ready.promise, registry, state
        });
        let called = false;
        let key = `${tracker.namespace}:${tracker.namespace}`;

        registry.addCommand(tracker.namespace, {
          execute: () => { called = true; }
        });
        state.save(key, { data: null }).then(() => {
          return restorer.restore(tracker, {
            args: () => null,
            name: () => tracker.namespace,
            command: tracker.namespace
          });
        }).catch(done);
        ready.resolve(void 0);
        restorer.restored.then(() => { expect(called).to.be(true); })
          .then(() => state.remove(key))
          .then(() => { done(); })
          .catch(done);
      });

    it('should allow an overwrite data transformation', async () => {
      const transform = new PromiseDelegate<StateDB.DataTransform>();
      const db = new StateDB({
        namespace: 'test',
        transform: transform.promise
      });
      const prepopulate = new StateDB({ namespace: 'test' });
      const key = 'foo';
      const correct = 'bar';
      const incorrect = 'baz';
      const transformation: StateDB.DataTransform = {
        type: 'overwrite',
        contents: { [key]: correct }
      };

      // By sharing a namespace, the two databases will share data.
      await prepopulate.save(key, incorrect);
      let value = await prepopulate.fetch(key);
      expect(value).to.equal(incorrect);
      transform.resolve(transformation);
      await transform.promise;
      value = await db.fetch(key);
      expect(value).to.equal(correct);
      await db.clear();
    });

 it('should resolve the underlying promise', done => {
   let delegate = new PromiseDelegate<number>();
   delegate.promise.then(value => {
     expect(value).to.equal(1);
     done();
   });
   delegate.resolve(1);
 });

 .then(saved => {
   // If this command is called after a reset, the state database
   // will already be resolved.
   if (!resolved) {
     resolved = true;
     transform.resolve({ type: 'overwrite', contents: saved.data });
   }
 })