TypeScript ImmutableList.of方法代码示例

    it('should set the correct target element to active', () => {
      const rootEl = Mocks.object('rootEl');
      const fullPath = 'fullPath';

      const slotName = 'slotName';
      const path = 'path';
      const childWithPath = document.createElement('div');
      childWithPath.setAttribute('gs-view-path', path);
      childWithPath.setAttribute('slot', slotName);

      const childNoPath = document.createElement('div');

      const element = document.createElement('div');
      element.appendChild(childNoPath);
      element.appendChild(childWithPath);
      element[__fullPath] = fullPath;

      const appendedPath = 'appendedPath';
      spyOn(LocationService, 'appendParts').and.returnValue(appendedPath);

      spyOn(LocationService, 'hasMatch').and.returnValue(true);

      spyOn(viewSlot, 'setRootElVisible_');

      const fakeSwitchValueSetter = new FakeMonadSetter<string | null>(null);

      const updates = viewSlot.updateActiveView_(element, rootEl, fakeSwitchValueSetter);
      assert(fakeSwitchValueSetter.findValue(updates)!.value).to.equal(slotName);
      assert(viewSlot['setRootElVisible_']).to.haveBeenCalledWith(rootEl, true);
      assert(LocationService.appendParts).to.haveBeenCalledWith(ImmutableList.of([fullPath, path]));
      assert(LocationService.hasMatch).to.haveBeenCalledWith(appendedPath);
      assert(childWithPath.getAttribute('gs-view-active')).to.equal('true');
    });

    it('should return true if every item has one of the specified mime type', () => {
      const mimeType1 = 'mimeType1';
      const mimeType2 = 'mimeType2';

      const dataTransfer = Mocks.object('dataTransfer');
      dataTransfer.items = [{type: mimeType1}, {type: mimeType2}];

      assert(input['isValid_'](ImmutableList.of([mimeType1, mimeType2]), dataTransfer)).to.beTrue();
    });

 /**
  * @param params Params to create the paths.
  * @return Array of paths for the current route and its ancestors. The oldest ancestors come
  *    first in the array.
  */
 getCascadePaths(params: CR): string[] {
   const paths: string[] = [];
   let current: AbstractRouteFactory<any, any, any, any> | null = this;
   while (current !== null) {
     paths.push(current.getPath(params));
     current = current.parent_;
   }
   return [...ImmutableList.of(paths).reverse()];
 }

 /**
  * @param params Params to determine the name of the route.
  * @return Array of names of the current route and its ancestors. The oldest ancestors come
  *    first in the array.
  */
 getCascadeNames(params: CR): Promise<string>[] {
   const names: Promise<string>[] = [];
   let current: AbstractRouteFactory<any, any, any, any> | null = this;
   while (current !== null) {
     names.push(current.getName(params));
     current = current.parent_;
   }
   return [...ImmutableList.of(names).reverse()];
 }

 async getCascadeCrumbs(params: CR): Promise<{name: string, url: string}[]> {
   const crumbs: {name: string, url: string}[] = [];
   let current: AbstractRouteFactory<any, any, any, any> | null = this;
   while (current !== null) {
     crumbs.push({
       name: await current.getName(params),
       url: current.getPath(params),
     });
     current = current.parent_;
   }
   return [...ImmutableList.of(crumbs).reverse()];
 }

  it(`should return the correct map`, () => {
    const type1 = Mocks.object('type1');
    const mockFactory1 = jasmine.createSpyObj('Factory1', ['getType']);
    mockFactory1.getType.and.returnValue(type1);

    const type2 = Mocks.object('type2');
    const mockFactory2 = jasmine.createSpyObj('Factory2', ['getType']);
    mockFactory2.getType.and.returnValue(type2);

    const routeFactories = ImmutableList.of([mockFactory1, mockFactory2]);

    assert(providesRouteFactoryMap(routeFactories)).to.haveElements([
      [type1, mockFactory1],
      [type2, mockFactory2],
    ]);
  });